]> 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
cleanup - added whitespace around operators, some blank lines, fixed comment typos...
[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,unsigned 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,unsigned 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,unsigned 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 *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9817 PyObject *resultobj = 0;
9818 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9819 void *argp1 = 0 ;
9820 int res1 = 0 ;
9821 PyObject *swig_obj[1] ;
9822
9823 if (!args) SWIG_fail;
9824 swig_obj[0] = args;
9825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9826 if (!SWIG_IsOK(res1)) {
9827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9828 }
9829 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9830 {
9831 PyThreadState* __tstate = wxPyBeginAllowThreads();
9832 delete arg1;
9833
9834 wxPyEndAllowThreads(__tstate);
9835 if (PyErr_Occurred()) SWIG_fail;
9836 }
9837 resultobj = SWIG_Py_Void();
9838 return resultobj;
9839 fail:
9840 return NULL;
9841 }
9842
9843
9844 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9845 PyObject *obj;
9846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9847 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9848 return SWIG_Py_Void();
9849 }
9850
9851 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9852 PyObject *resultobj = 0;
9853 wxPyFileSystemHandler *result = 0 ;
9854
9855 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9856 {
9857 PyThreadState* __tstate = wxPyBeginAllowThreads();
9858 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9859 wxPyEndAllowThreads(__tstate);
9860 if (PyErr_Occurred()) SWIG_fail;
9861 }
9862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9863 return resultobj;
9864 fail:
9865 return NULL;
9866 }
9867
9868
9869 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9870 PyObject *resultobj = 0;
9871 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9872 PyObject *arg2 = (PyObject *) 0 ;
9873 PyObject *arg3 = (PyObject *) 0 ;
9874 void *argp1 = 0 ;
9875 int res1 = 0 ;
9876 PyObject * obj0 = 0 ;
9877 PyObject * obj1 = 0 ;
9878 PyObject * obj2 = 0 ;
9879 char * kwnames[] = {
9880 (char *) "self",(char *) "self",(char *) "_class", NULL
9881 };
9882
9883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9885 if (!SWIG_IsOK(res1)) {
9886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9887 }
9888 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9889 arg2 = obj1;
9890 arg3 = obj2;
9891 {
9892 PyThreadState* __tstate = wxPyBeginAllowThreads();
9893 (arg1)->_setCallbackInfo(arg2,arg3);
9894 wxPyEndAllowThreads(__tstate);
9895 if (PyErr_Occurred()) SWIG_fail;
9896 }
9897 resultobj = SWIG_Py_Void();
9898 return resultobj;
9899 fail:
9900 return NULL;
9901 }
9902
9903
9904 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9905 PyObject *resultobj = 0;
9906 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9907 wxString *arg2 = 0 ;
9908 bool result;
9909 void *argp1 = 0 ;
9910 int res1 = 0 ;
9911 bool temp2 = false ;
9912 PyObject * obj0 = 0 ;
9913 PyObject * obj1 = 0 ;
9914 char * kwnames[] = {
9915 (char *) "self",(char *) "location", NULL
9916 };
9917
9918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9920 if (!SWIG_IsOK(res1)) {
9921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9922 }
9923 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9924 {
9925 arg2 = wxString_in_helper(obj1);
9926 if (arg2 == NULL) SWIG_fail;
9927 temp2 = true;
9928 }
9929 {
9930 PyThreadState* __tstate = wxPyBeginAllowThreads();
9931 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9932 wxPyEndAllowThreads(__tstate);
9933 if (PyErr_Occurred()) SWIG_fail;
9934 }
9935 {
9936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9937 }
9938 {
9939 if (temp2)
9940 delete arg2;
9941 }
9942 return resultobj;
9943 fail:
9944 {
9945 if (temp2)
9946 delete arg2;
9947 }
9948 return NULL;
9949 }
9950
9951
9952 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9953 PyObject *resultobj = 0;
9954 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9955 wxFileSystem *arg2 = 0 ;
9956 wxString *arg3 = 0 ;
9957 wxFSFile *result = 0 ;
9958 void *argp1 = 0 ;
9959 int res1 = 0 ;
9960 void *argp2 = 0 ;
9961 int res2 = 0 ;
9962 bool temp3 = false ;
9963 PyObject * obj0 = 0 ;
9964 PyObject * obj1 = 0 ;
9965 PyObject * obj2 = 0 ;
9966 char * kwnames[] = {
9967 (char *) "self",(char *) "fs",(char *) "location", NULL
9968 };
9969
9970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9972 if (!SWIG_IsOK(res1)) {
9973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9974 }
9975 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9976 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
9977 if (!SWIG_IsOK(res2)) {
9978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9979 }
9980 if (!argp2) {
9981 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9982 }
9983 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
9984 {
9985 arg3 = wxString_in_helper(obj2);
9986 if (arg3 == NULL) SWIG_fail;
9987 temp3 = true;
9988 }
9989 {
9990 PyThreadState* __tstate = wxPyBeginAllowThreads();
9991 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9992 wxPyEndAllowThreads(__tstate);
9993 if (PyErr_Occurred()) SWIG_fail;
9994 }
9995 {
9996 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
9997 }
9998 {
9999 if (temp3)
10000 delete arg3;
10001 }
10002 return resultobj;
10003 fail:
10004 {
10005 if (temp3)
10006 delete arg3;
10007 }
10008 return NULL;
10009 }
10010
10011
10012 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10013 PyObject *resultobj = 0;
10014 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10015 wxString *arg2 = 0 ;
10016 int arg3 = (int) 0 ;
10017 wxString result;
10018 void *argp1 = 0 ;
10019 int res1 = 0 ;
10020 bool temp2 = false ;
10021 int val3 ;
10022 int ecode3 = 0 ;
10023 PyObject * obj0 = 0 ;
10024 PyObject * obj1 = 0 ;
10025 PyObject * obj2 = 0 ;
10026 char * kwnames[] = {
10027 (char *) "self",(char *) "spec",(char *) "flags", NULL
10028 };
10029
10030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10032 if (!SWIG_IsOK(res1)) {
10033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10034 }
10035 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10036 {
10037 arg2 = wxString_in_helper(obj1);
10038 if (arg2 == NULL) SWIG_fail;
10039 temp2 = true;
10040 }
10041 if (obj2) {
10042 ecode3 = SWIG_AsVal_int(obj2, &val3);
10043 if (!SWIG_IsOK(ecode3)) {
10044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10045 }
10046 arg3 = static_cast< int >(val3);
10047 }
10048 {
10049 PyThreadState* __tstate = wxPyBeginAllowThreads();
10050 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10051 wxPyEndAllowThreads(__tstate);
10052 if (PyErr_Occurred()) SWIG_fail;
10053 }
10054 {
10055 #if wxUSE_UNICODE
10056 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10057 #else
10058 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10059 #endif
10060 }
10061 {
10062 if (temp2)
10063 delete arg2;
10064 }
10065 return resultobj;
10066 fail:
10067 {
10068 if (temp2)
10069 delete arg2;
10070 }
10071 return NULL;
10072 }
10073
10074
10075 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10076 PyObject *resultobj = 0;
10077 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10078 wxString result;
10079 void *argp1 = 0 ;
10080 int res1 = 0 ;
10081 PyObject *swig_obj[1] ;
10082
10083 if (!args) SWIG_fail;
10084 swig_obj[0] = args;
10085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10086 if (!SWIG_IsOK(res1)) {
10087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10088 }
10089 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10090 {
10091 PyThreadState* __tstate = wxPyBeginAllowThreads();
10092 result = (arg1)->FindNext();
10093 wxPyEndAllowThreads(__tstate);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 {
10097 #if wxUSE_UNICODE
10098 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10099 #else
10100 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10101 #endif
10102 }
10103 return resultobj;
10104 fail:
10105 return NULL;
10106 }
10107
10108
10109 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10110 PyObject *resultobj = 0;
10111 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10112 wxString *arg2 = 0 ;
10113 wxString result;
10114 void *argp1 = 0 ;
10115 int res1 = 0 ;
10116 bool temp2 = false ;
10117 PyObject * obj0 = 0 ;
10118 PyObject * obj1 = 0 ;
10119 char * kwnames[] = {
10120 (char *) "self",(char *) "location", NULL
10121 };
10122
10123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10125 if (!SWIG_IsOK(res1)) {
10126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10127 }
10128 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10129 {
10130 arg2 = wxString_in_helper(obj1);
10131 if (arg2 == NULL) SWIG_fail;
10132 temp2 = true;
10133 }
10134 {
10135 PyThreadState* __tstate = wxPyBeginAllowThreads();
10136 result = (arg1)->GetProtocol((wxString const &)*arg2);
10137 wxPyEndAllowThreads(__tstate);
10138 if (PyErr_Occurred()) SWIG_fail;
10139 }
10140 {
10141 #if wxUSE_UNICODE
10142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10143 #else
10144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10145 #endif
10146 }
10147 {
10148 if (temp2)
10149 delete arg2;
10150 }
10151 return resultobj;
10152 fail:
10153 {
10154 if (temp2)
10155 delete arg2;
10156 }
10157 return NULL;
10158 }
10159
10160
10161 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10162 PyObject *resultobj = 0;
10163 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10164 wxString *arg2 = 0 ;
10165 wxString result;
10166 void *argp1 = 0 ;
10167 int res1 = 0 ;
10168 bool temp2 = false ;
10169 PyObject * obj0 = 0 ;
10170 PyObject * obj1 = 0 ;
10171 char * kwnames[] = {
10172 (char *) "self",(char *) "location", NULL
10173 };
10174
10175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10177 if (!SWIG_IsOK(res1)) {
10178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10179 }
10180 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10181 {
10182 arg2 = wxString_in_helper(obj1);
10183 if (arg2 == NULL) SWIG_fail;
10184 temp2 = true;
10185 }
10186 {
10187 PyThreadState* __tstate = wxPyBeginAllowThreads();
10188 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10189 wxPyEndAllowThreads(__tstate);
10190 if (PyErr_Occurred()) SWIG_fail;
10191 }
10192 {
10193 #if wxUSE_UNICODE
10194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10195 #else
10196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10197 #endif
10198 }
10199 {
10200 if (temp2)
10201 delete arg2;
10202 }
10203 return resultobj;
10204 fail:
10205 {
10206 if (temp2)
10207 delete arg2;
10208 }
10209 return NULL;
10210 }
10211
10212
10213 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10214 PyObject *resultobj = 0;
10215 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10216 wxString *arg2 = 0 ;
10217 wxString result;
10218 void *argp1 = 0 ;
10219 int res1 = 0 ;
10220 bool temp2 = false ;
10221 PyObject * obj0 = 0 ;
10222 PyObject * obj1 = 0 ;
10223 char * kwnames[] = {
10224 (char *) "self",(char *) "location", NULL
10225 };
10226
10227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10229 if (!SWIG_IsOK(res1)) {
10230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10231 }
10232 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10233 {
10234 arg2 = wxString_in_helper(obj1);
10235 if (arg2 == NULL) SWIG_fail;
10236 temp2 = true;
10237 }
10238 {
10239 PyThreadState* __tstate = wxPyBeginAllowThreads();
10240 result = (arg1)->GetAnchor((wxString const &)*arg2);
10241 wxPyEndAllowThreads(__tstate);
10242 if (PyErr_Occurred()) SWIG_fail;
10243 }
10244 {
10245 #if wxUSE_UNICODE
10246 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10247 #else
10248 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10249 #endif
10250 }
10251 {
10252 if (temp2)
10253 delete arg2;
10254 }
10255 return resultobj;
10256 fail:
10257 {
10258 if (temp2)
10259 delete arg2;
10260 }
10261 return NULL;
10262 }
10263
10264
10265 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10266 PyObject *resultobj = 0;
10267 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10268 wxString *arg2 = 0 ;
10269 wxString result;
10270 void *argp1 = 0 ;
10271 int res1 = 0 ;
10272 bool temp2 = false ;
10273 PyObject * obj0 = 0 ;
10274 PyObject * obj1 = 0 ;
10275 char * kwnames[] = {
10276 (char *) "self",(char *) "location", NULL
10277 };
10278
10279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10281 if (!SWIG_IsOK(res1)) {
10282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10283 }
10284 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10285 {
10286 arg2 = wxString_in_helper(obj1);
10287 if (arg2 == NULL) SWIG_fail;
10288 temp2 = true;
10289 }
10290 {
10291 PyThreadState* __tstate = wxPyBeginAllowThreads();
10292 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10293 wxPyEndAllowThreads(__tstate);
10294 if (PyErr_Occurred()) SWIG_fail;
10295 }
10296 {
10297 #if wxUSE_UNICODE
10298 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10299 #else
10300 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10301 #endif
10302 }
10303 {
10304 if (temp2)
10305 delete arg2;
10306 }
10307 return resultobj;
10308 fail:
10309 {
10310 if (temp2)
10311 delete arg2;
10312 }
10313 return NULL;
10314 }
10315
10316
10317 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10318 PyObject *resultobj = 0;
10319 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10320 wxString *arg2 = 0 ;
10321 wxString result;
10322 void *argp1 = 0 ;
10323 int res1 = 0 ;
10324 bool temp2 = false ;
10325 PyObject * obj0 = 0 ;
10326 PyObject * obj1 = 0 ;
10327 char * kwnames[] = {
10328 (char *) "self",(char *) "location", NULL
10329 };
10330
10331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10333 if (!SWIG_IsOK(res1)) {
10334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10335 }
10336 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10337 {
10338 arg2 = wxString_in_helper(obj1);
10339 if (arg2 == NULL) SWIG_fail;
10340 temp2 = true;
10341 }
10342 {
10343 PyThreadState* __tstate = wxPyBeginAllowThreads();
10344 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10345 wxPyEndAllowThreads(__tstate);
10346 if (PyErr_Occurred()) SWIG_fail;
10347 }
10348 {
10349 #if wxUSE_UNICODE
10350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10351 #else
10352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10353 #endif
10354 }
10355 {
10356 if (temp2)
10357 delete arg2;
10358 }
10359 return resultobj;
10360 fail:
10361 {
10362 if (temp2)
10363 delete arg2;
10364 }
10365 return NULL;
10366 }
10367
10368
10369 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10370 PyObject *obj;
10371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10372 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10373 return SWIG_Py_Void();
10374 }
10375
10376 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10377 return SWIG_Python_InitShadowInstance(args);
10378 }
10379
10380 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10381 PyObject *resultobj = 0;
10382 wxFileSystem *result = 0 ;
10383
10384 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10385 {
10386 PyThreadState* __tstate = wxPyBeginAllowThreads();
10387 result = (wxFileSystem *)new wxFileSystem();
10388 wxPyEndAllowThreads(__tstate);
10389 if (PyErr_Occurred()) SWIG_fail;
10390 }
10391 {
10392 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10393 }
10394 return resultobj;
10395 fail:
10396 return NULL;
10397 }
10398
10399
10400 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10401 PyObject *resultobj = 0;
10402 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10403 void *argp1 = 0 ;
10404 int res1 = 0 ;
10405 PyObject *swig_obj[1] ;
10406
10407 if (!args) SWIG_fail;
10408 swig_obj[0] = args;
10409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10410 if (!SWIG_IsOK(res1)) {
10411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10412 }
10413 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10414 {
10415 PyThreadState* __tstate = wxPyBeginAllowThreads();
10416 delete arg1;
10417
10418 wxPyEndAllowThreads(__tstate);
10419 if (PyErr_Occurred()) SWIG_fail;
10420 }
10421 resultobj = SWIG_Py_Void();
10422 return resultobj;
10423 fail:
10424 return NULL;
10425 }
10426
10427
10428 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10429 PyObject *resultobj = 0;
10430 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10431 wxString *arg2 = 0 ;
10432 bool arg3 = (bool) false ;
10433 void *argp1 = 0 ;
10434 int res1 = 0 ;
10435 bool temp2 = false ;
10436 bool val3 ;
10437 int ecode3 = 0 ;
10438 PyObject * obj0 = 0 ;
10439 PyObject * obj1 = 0 ;
10440 PyObject * obj2 = 0 ;
10441 char * kwnames[] = {
10442 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10443 };
10444
10445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10447 if (!SWIG_IsOK(res1)) {
10448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10449 }
10450 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10451 {
10452 arg2 = wxString_in_helper(obj1);
10453 if (arg2 == NULL) SWIG_fail;
10454 temp2 = true;
10455 }
10456 if (obj2) {
10457 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10458 if (!SWIG_IsOK(ecode3)) {
10459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10460 }
10461 arg3 = static_cast< bool >(val3);
10462 }
10463 {
10464 PyThreadState* __tstate = wxPyBeginAllowThreads();
10465 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10466 wxPyEndAllowThreads(__tstate);
10467 if (PyErr_Occurred()) SWIG_fail;
10468 }
10469 resultobj = SWIG_Py_Void();
10470 {
10471 if (temp2)
10472 delete arg2;
10473 }
10474 return resultobj;
10475 fail:
10476 {
10477 if (temp2)
10478 delete arg2;
10479 }
10480 return NULL;
10481 }
10482
10483
10484 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10485 PyObject *resultobj = 0;
10486 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10487 wxString result;
10488 void *argp1 = 0 ;
10489 int res1 = 0 ;
10490 PyObject *swig_obj[1] ;
10491
10492 if (!args) SWIG_fail;
10493 swig_obj[0] = args;
10494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10495 if (!SWIG_IsOK(res1)) {
10496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10497 }
10498 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10499 {
10500 PyThreadState* __tstate = wxPyBeginAllowThreads();
10501 result = (arg1)->GetPath();
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 {
10506 #if wxUSE_UNICODE
10507 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10508 #else
10509 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10510 #endif
10511 }
10512 return resultobj;
10513 fail:
10514 return NULL;
10515 }
10516
10517
10518 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10519 PyObject *resultobj = 0;
10520 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10521 wxString *arg2 = 0 ;
10522 wxFSFile *result = 0 ;
10523 void *argp1 = 0 ;
10524 int res1 = 0 ;
10525 bool temp2 = false ;
10526 PyObject * obj0 = 0 ;
10527 PyObject * obj1 = 0 ;
10528 char * kwnames[] = {
10529 (char *) "self",(char *) "location", NULL
10530 };
10531
10532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10534 if (!SWIG_IsOK(res1)) {
10535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10536 }
10537 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10538 {
10539 arg2 = wxString_in_helper(obj1);
10540 if (arg2 == NULL) SWIG_fail;
10541 temp2 = true;
10542 }
10543 {
10544 PyThreadState* __tstate = wxPyBeginAllowThreads();
10545 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10546 wxPyEndAllowThreads(__tstate);
10547 if (PyErr_Occurred()) SWIG_fail;
10548 }
10549 {
10550 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10551 }
10552 {
10553 if (temp2)
10554 delete arg2;
10555 }
10556 return resultobj;
10557 fail:
10558 {
10559 if (temp2)
10560 delete arg2;
10561 }
10562 return NULL;
10563 }
10564
10565
10566 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10567 PyObject *resultobj = 0;
10568 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10569 wxString *arg2 = 0 ;
10570 int arg3 = (int) 0 ;
10571 wxString result;
10572 void *argp1 = 0 ;
10573 int res1 = 0 ;
10574 bool temp2 = false ;
10575 int val3 ;
10576 int ecode3 = 0 ;
10577 PyObject * obj0 = 0 ;
10578 PyObject * obj1 = 0 ;
10579 PyObject * obj2 = 0 ;
10580 char * kwnames[] = {
10581 (char *) "self",(char *) "spec",(char *) "flags", NULL
10582 };
10583
10584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10586 if (!SWIG_IsOK(res1)) {
10587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10588 }
10589 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10590 {
10591 arg2 = wxString_in_helper(obj1);
10592 if (arg2 == NULL) SWIG_fail;
10593 temp2 = true;
10594 }
10595 if (obj2) {
10596 ecode3 = SWIG_AsVal_int(obj2, &val3);
10597 if (!SWIG_IsOK(ecode3)) {
10598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10599 }
10600 arg3 = static_cast< int >(val3);
10601 }
10602 {
10603 PyThreadState* __tstate = wxPyBeginAllowThreads();
10604 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10605 wxPyEndAllowThreads(__tstate);
10606 if (PyErr_Occurred()) SWIG_fail;
10607 }
10608 {
10609 #if wxUSE_UNICODE
10610 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10611 #else
10612 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10613 #endif
10614 }
10615 {
10616 if (temp2)
10617 delete arg2;
10618 }
10619 return resultobj;
10620 fail:
10621 {
10622 if (temp2)
10623 delete arg2;
10624 }
10625 return NULL;
10626 }
10627
10628
10629 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10630 PyObject *resultobj = 0;
10631 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10632 wxString result;
10633 void *argp1 = 0 ;
10634 int res1 = 0 ;
10635 PyObject *swig_obj[1] ;
10636
10637 if (!args) SWIG_fail;
10638 swig_obj[0] = args;
10639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10640 if (!SWIG_IsOK(res1)) {
10641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10642 }
10643 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10644 {
10645 PyThreadState* __tstate = wxPyBeginAllowThreads();
10646 result = (arg1)->FindNext();
10647 wxPyEndAllowThreads(__tstate);
10648 if (PyErr_Occurred()) SWIG_fail;
10649 }
10650 {
10651 #if wxUSE_UNICODE
10652 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10653 #else
10654 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10655 #endif
10656 }
10657 return resultobj;
10658 fail:
10659 return NULL;
10660 }
10661
10662
10663 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10664 PyObject *resultobj = 0;
10665 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10666 int res1 = 0 ;
10667 PyObject * obj0 = 0 ;
10668 char * kwnames[] = {
10669 (char *) "handler", NULL
10670 };
10671
10672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10673 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10674 if (!SWIG_IsOK(res1)) {
10675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10676 }
10677 {
10678 PyThreadState* __tstate = wxPyBeginAllowThreads();
10679 wxFileSystem::AddHandler(arg1);
10680 wxPyEndAllowThreads(__tstate);
10681 if (PyErr_Occurred()) SWIG_fail;
10682 }
10683 resultobj = SWIG_Py_Void();
10684 return resultobj;
10685 fail:
10686 return NULL;
10687 }
10688
10689
10690 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10691 PyObject *resultobj = 0;
10692
10693 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10694 {
10695 PyThreadState* __tstate = wxPyBeginAllowThreads();
10696 wxFileSystem::CleanUpHandlers();
10697 wxPyEndAllowThreads(__tstate);
10698 if (PyErr_Occurred()) SWIG_fail;
10699 }
10700 resultobj = SWIG_Py_Void();
10701 return resultobj;
10702 fail:
10703 return NULL;
10704 }
10705
10706
10707 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10708 PyObject *resultobj = 0;
10709 wxString *arg1 = 0 ;
10710 wxString result;
10711 bool temp1 = false ;
10712 PyObject * obj0 = 0 ;
10713 char * kwnames[] = {
10714 (char *) "filename", NULL
10715 };
10716
10717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10718 {
10719 arg1 = wxString_in_helper(obj0);
10720 if (arg1 == NULL) SWIG_fail;
10721 temp1 = true;
10722 }
10723 {
10724 PyThreadState* __tstate = wxPyBeginAllowThreads();
10725 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10726 wxPyEndAllowThreads(__tstate);
10727 if (PyErr_Occurred()) SWIG_fail;
10728 }
10729 {
10730 #if wxUSE_UNICODE
10731 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10732 #else
10733 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10734 #endif
10735 }
10736 {
10737 if (temp1)
10738 delete arg1;
10739 }
10740 return resultobj;
10741 fail:
10742 {
10743 if (temp1)
10744 delete arg1;
10745 }
10746 return NULL;
10747 }
10748
10749
10750 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10751 PyObject *resultobj = 0;
10752 wxString *arg1 = 0 ;
10753 wxString result;
10754 bool temp1 = false ;
10755 PyObject * obj0 = 0 ;
10756 char * kwnames[] = {
10757 (char *) "url", NULL
10758 };
10759
10760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10761 {
10762 arg1 = wxString_in_helper(obj0);
10763 if (arg1 == NULL) SWIG_fail;
10764 temp1 = true;
10765 }
10766 {
10767 PyThreadState* __tstate = wxPyBeginAllowThreads();
10768 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10769 wxPyEndAllowThreads(__tstate);
10770 if (PyErr_Occurred()) SWIG_fail;
10771 }
10772 {
10773 #if wxUSE_UNICODE
10774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10775 #else
10776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10777 #endif
10778 }
10779 {
10780 if (temp1)
10781 delete arg1;
10782 }
10783 return resultobj;
10784 fail:
10785 {
10786 if (temp1)
10787 delete arg1;
10788 }
10789 return NULL;
10790 }
10791
10792
10793 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10794 PyObject *obj;
10795 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10796 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10797 return SWIG_Py_Void();
10798 }
10799
10800 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10801 return SWIG_Python_InitShadowInstance(args);
10802 }
10803
10804 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10805 PyObject *resultobj = 0;
10806 wxInternetFSHandler *result = 0 ;
10807
10808 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10809 {
10810 PyThreadState* __tstate = wxPyBeginAllowThreads();
10811 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10812 wxPyEndAllowThreads(__tstate);
10813 if (PyErr_Occurred()) SWIG_fail;
10814 }
10815 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10816 return resultobj;
10817 fail:
10818 return NULL;
10819 }
10820
10821
10822 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10823 PyObject *resultobj = 0;
10824 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10825 wxString *arg2 = 0 ;
10826 bool result;
10827 void *argp1 = 0 ;
10828 int res1 = 0 ;
10829 bool temp2 = false ;
10830 PyObject * obj0 = 0 ;
10831 PyObject * obj1 = 0 ;
10832 char * kwnames[] = {
10833 (char *) "self",(char *) "location", NULL
10834 };
10835
10836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10838 if (!SWIG_IsOK(res1)) {
10839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10840 }
10841 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10842 {
10843 arg2 = wxString_in_helper(obj1);
10844 if (arg2 == NULL) SWIG_fail;
10845 temp2 = true;
10846 }
10847 {
10848 PyThreadState* __tstate = wxPyBeginAllowThreads();
10849 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10850 wxPyEndAllowThreads(__tstate);
10851 if (PyErr_Occurred()) SWIG_fail;
10852 }
10853 {
10854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10855 }
10856 {
10857 if (temp2)
10858 delete arg2;
10859 }
10860 return resultobj;
10861 fail:
10862 {
10863 if (temp2)
10864 delete arg2;
10865 }
10866 return NULL;
10867 }
10868
10869
10870 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10871 PyObject *resultobj = 0;
10872 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10873 wxFileSystem *arg2 = 0 ;
10874 wxString *arg3 = 0 ;
10875 wxFSFile *result = 0 ;
10876 void *argp1 = 0 ;
10877 int res1 = 0 ;
10878 void *argp2 = 0 ;
10879 int res2 = 0 ;
10880 bool temp3 = false ;
10881 PyObject * obj0 = 0 ;
10882 PyObject * obj1 = 0 ;
10883 PyObject * obj2 = 0 ;
10884 char * kwnames[] = {
10885 (char *) "self",(char *) "fs",(char *) "location", NULL
10886 };
10887
10888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10890 if (!SWIG_IsOK(res1)) {
10891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10892 }
10893 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10894 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10895 if (!SWIG_IsOK(res2)) {
10896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10897 }
10898 if (!argp2) {
10899 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10900 }
10901 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10902 {
10903 arg3 = wxString_in_helper(obj2);
10904 if (arg3 == NULL) SWIG_fail;
10905 temp3 = true;
10906 }
10907 {
10908 PyThreadState* __tstate = wxPyBeginAllowThreads();
10909 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10910 wxPyEndAllowThreads(__tstate);
10911 if (PyErr_Occurred()) SWIG_fail;
10912 }
10913 {
10914 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10915 }
10916 {
10917 if (temp3)
10918 delete arg3;
10919 }
10920 return resultobj;
10921 fail:
10922 {
10923 if (temp3)
10924 delete arg3;
10925 }
10926 return NULL;
10927 }
10928
10929
10930 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10931 PyObject *obj;
10932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10933 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
10934 return SWIG_Py_Void();
10935 }
10936
10937 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10938 return SWIG_Python_InitShadowInstance(args);
10939 }
10940
10941 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10942 PyObject *resultobj = 0;
10943 wxZipFSHandler *result = 0 ;
10944
10945 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
10946 {
10947 PyThreadState* __tstate = wxPyBeginAllowThreads();
10948 result = (wxZipFSHandler *)new wxZipFSHandler();
10949 wxPyEndAllowThreads(__tstate);
10950 if (PyErr_Occurred()) SWIG_fail;
10951 }
10952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
10953 return resultobj;
10954 fail:
10955 return NULL;
10956 }
10957
10958
10959 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10960 PyObject *resultobj = 0;
10961 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10962 wxString *arg2 = 0 ;
10963 bool result;
10964 void *argp1 = 0 ;
10965 int res1 = 0 ;
10966 bool temp2 = false ;
10967 PyObject * obj0 = 0 ;
10968 PyObject * obj1 = 0 ;
10969 char * kwnames[] = {
10970 (char *) "self",(char *) "location", NULL
10971 };
10972
10973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
10975 if (!SWIG_IsOK(res1)) {
10976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
10977 }
10978 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
10979 {
10980 arg2 = wxString_in_helper(obj1);
10981 if (arg2 == NULL) SWIG_fail;
10982 temp2 = true;
10983 }
10984 {
10985 PyThreadState* __tstate = wxPyBeginAllowThreads();
10986 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10987 wxPyEndAllowThreads(__tstate);
10988 if (PyErr_Occurred()) SWIG_fail;
10989 }
10990 {
10991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10992 }
10993 {
10994 if (temp2)
10995 delete arg2;
10996 }
10997 return resultobj;
10998 fail:
10999 {
11000 if (temp2)
11001 delete arg2;
11002 }
11003 return NULL;
11004 }
11005
11006
11007 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11008 PyObject *resultobj = 0;
11009 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11010 wxFileSystem *arg2 = 0 ;
11011 wxString *arg3 = 0 ;
11012 wxFSFile *result = 0 ;
11013 void *argp1 = 0 ;
11014 int res1 = 0 ;
11015 void *argp2 = 0 ;
11016 int res2 = 0 ;
11017 bool temp3 = false ;
11018 PyObject * obj0 = 0 ;
11019 PyObject * obj1 = 0 ;
11020 PyObject * obj2 = 0 ;
11021 char * kwnames[] = {
11022 (char *) "self",(char *) "fs",(char *) "location", NULL
11023 };
11024
11025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11027 if (!SWIG_IsOK(res1)) {
11028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11029 }
11030 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11031 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11032 if (!SWIG_IsOK(res2)) {
11033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11034 }
11035 if (!argp2) {
11036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11037 }
11038 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11039 {
11040 arg3 = wxString_in_helper(obj2);
11041 if (arg3 == NULL) SWIG_fail;
11042 temp3 = true;
11043 }
11044 {
11045 PyThreadState* __tstate = wxPyBeginAllowThreads();
11046 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11047 wxPyEndAllowThreads(__tstate);
11048 if (PyErr_Occurred()) SWIG_fail;
11049 }
11050 {
11051 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11052 }
11053 {
11054 if (temp3)
11055 delete arg3;
11056 }
11057 return resultobj;
11058 fail:
11059 {
11060 if (temp3)
11061 delete arg3;
11062 }
11063 return NULL;
11064 }
11065
11066
11067 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11068 PyObject *resultobj = 0;
11069 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11070 wxString *arg2 = 0 ;
11071 int arg3 = (int) 0 ;
11072 wxString result;
11073 void *argp1 = 0 ;
11074 int res1 = 0 ;
11075 bool temp2 = false ;
11076 int val3 ;
11077 int ecode3 = 0 ;
11078 PyObject * obj0 = 0 ;
11079 PyObject * obj1 = 0 ;
11080 PyObject * obj2 = 0 ;
11081 char * kwnames[] = {
11082 (char *) "self",(char *) "spec",(char *) "flags", NULL
11083 };
11084
11085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11087 if (!SWIG_IsOK(res1)) {
11088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11089 }
11090 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11091 {
11092 arg2 = wxString_in_helper(obj1);
11093 if (arg2 == NULL) SWIG_fail;
11094 temp2 = true;
11095 }
11096 if (obj2) {
11097 ecode3 = SWIG_AsVal_int(obj2, &val3);
11098 if (!SWIG_IsOK(ecode3)) {
11099 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11100 }
11101 arg3 = static_cast< int >(val3);
11102 }
11103 {
11104 PyThreadState* __tstate = wxPyBeginAllowThreads();
11105 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11106 wxPyEndAllowThreads(__tstate);
11107 if (PyErr_Occurred()) SWIG_fail;
11108 }
11109 {
11110 #if wxUSE_UNICODE
11111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11112 #else
11113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11114 #endif
11115 }
11116 {
11117 if (temp2)
11118 delete arg2;
11119 }
11120 return resultobj;
11121 fail:
11122 {
11123 if (temp2)
11124 delete arg2;
11125 }
11126 return NULL;
11127 }
11128
11129
11130 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11131 PyObject *resultobj = 0;
11132 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11133 wxString result;
11134 void *argp1 = 0 ;
11135 int res1 = 0 ;
11136 PyObject *swig_obj[1] ;
11137
11138 if (!args) SWIG_fail;
11139 swig_obj[0] = args;
11140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11141 if (!SWIG_IsOK(res1)) {
11142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11143 }
11144 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11145 {
11146 PyThreadState* __tstate = wxPyBeginAllowThreads();
11147 result = (arg1)->FindNext();
11148 wxPyEndAllowThreads(__tstate);
11149 if (PyErr_Occurred()) SWIG_fail;
11150 }
11151 {
11152 #if wxUSE_UNICODE
11153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11154 #else
11155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11156 #endif
11157 }
11158 return resultobj;
11159 fail:
11160 return NULL;
11161 }
11162
11163
11164 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11165 PyObject *obj;
11166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11167 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11168 return SWIG_Py_Void();
11169 }
11170
11171 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11172 return SWIG_Python_InitShadowInstance(args);
11173 }
11174
11175 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11176 PyObject *resultobj = 0;
11177 wxString *arg1 = 0 ;
11178 wxImage *arg2 = 0 ;
11179 long arg3 ;
11180 bool temp1 = false ;
11181 void *argp2 = 0 ;
11182 int res2 = 0 ;
11183 long val3 ;
11184 int ecode3 = 0 ;
11185 PyObject * obj0 = 0 ;
11186 PyObject * obj1 = 0 ;
11187 PyObject * obj2 = 0 ;
11188 char * kwnames[] = {
11189 (char *) "filename",(char *) "image",(char *) "type", NULL
11190 };
11191
11192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11193 {
11194 arg1 = wxString_in_helper(obj0);
11195 if (arg1 == NULL) SWIG_fail;
11196 temp1 = true;
11197 }
11198 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11199 if (!SWIG_IsOK(res2)) {
11200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11201 }
11202 if (!argp2) {
11203 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11204 }
11205 arg2 = reinterpret_cast< wxImage * >(argp2);
11206 ecode3 = SWIG_AsVal_long(obj2, &val3);
11207 if (!SWIG_IsOK(ecode3)) {
11208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11209 }
11210 arg3 = static_cast< long >(val3);
11211 {
11212 PyThreadState* __tstate = wxPyBeginAllowThreads();
11213 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11214 wxPyEndAllowThreads(__tstate);
11215 if (PyErr_Occurred()) SWIG_fail;
11216 }
11217 resultobj = SWIG_Py_Void();
11218 {
11219 if (temp1)
11220 delete arg1;
11221 }
11222 return resultobj;
11223 fail:
11224 {
11225 if (temp1)
11226 delete arg1;
11227 }
11228 return NULL;
11229 }
11230
11231
11232 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11233 PyObject *resultobj = 0;
11234 wxString *arg1 = 0 ;
11235 wxBitmap *arg2 = 0 ;
11236 long arg3 ;
11237 bool temp1 = false ;
11238 void *argp2 = 0 ;
11239 int res2 = 0 ;
11240 long val3 ;
11241 int ecode3 = 0 ;
11242 PyObject * obj0 = 0 ;
11243 PyObject * obj1 = 0 ;
11244 PyObject * obj2 = 0 ;
11245 char * kwnames[] = {
11246 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11247 };
11248
11249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11250 {
11251 arg1 = wxString_in_helper(obj0);
11252 if (arg1 == NULL) SWIG_fail;
11253 temp1 = true;
11254 }
11255 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11256 if (!SWIG_IsOK(res2)) {
11257 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11258 }
11259 if (!argp2) {
11260 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11261 }
11262 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11263 ecode3 = SWIG_AsVal_long(obj2, &val3);
11264 if (!SWIG_IsOK(ecode3)) {
11265 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11266 }
11267 arg3 = static_cast< long >(val3);
11268 {
11269 PyThreadState* __tstate = wxPyBeginAllowThreads();
11270 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11271 wxPyEndAllowThreads(__tstate);
11272 if (PyErr_Occurred()) SWIG_fail;
11273 }
11274 resultobj = SWIG_Py_Void();
11275 {
11276 if (temp1)
11277 delete arg1;
11278 }
11279 return resultobj;
11280 fail:
11281 {
11282 if (temp1)
11283 delete arg1;
11284 }
11285 return NULL;
11286 }
11287
11288
11289 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11290 PyObject *resultobj = 0;
11291 wxString *arg1 = 0 ;
11292 PyObject *arg2 = (PyObject *) 0 ;
11293 bool temp1 = false ;
11294 PyObject * obj0 = 0 ;
11295 PyObject * obj1 = 0 ;
11296 char * kwnames[] = {
11297 (char *) "filename",(char *) "data", NULL
11298 };
11299
11300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11301 {
11302 arg1 = wxString_in_helper(obj0);
11303 if (arg1 == NULL) SWIG_fail;
11304 temp1 = true;
11305 }
11306 arg2 = obj1;
11307 {
11308 PyThreadState* __tstate = wxPyBeginAllowThreads();
11309 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11310 wxPyEndAllowThreads(__tstate);
11311 if (PyErr_Occurred()) SWIG_fail;
11312 }
11313 resultobj = SWIG_Py_Void();
11314 {
11315 if (temp1)
11316 delete arg1;
11317 }
11318 return resultobj;
11319 fail:
11320 {
11321 if (temp1)
11322 delete arg1;
11323 }
11324 return NULL;
11325 }
11326
11327
11328 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11329 PyObject *resultobj = 0;
11330 wxMemoryFSHandler *result = 0 ;
11331
11332 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11333 {
11334 PyThreadState* __tstate = wxPyBeginAllowThreads();
11335 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11336 wxPyEndAllowThreads(__tstate);
11337 if (PyErr_Occurred()) SWIG_fail;
11338 }
11339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11340 return resultobj;
11341 fail:
11342 return NULL;
11343 }
11344
11345
11346 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11347 PyObject *resultobj = 0;
11348 wxString *arg1 = 0 ;
11349 bool temp1 = false ;
11350 PyObject * obj0 = 0 ;
11351 char * kwnames[] = {
11352 (char *) "filename", NULL
11353 };
11354
11355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11356 {
11357 arg1 = wxString_in_helper(obj0);
11358 if (arg1 == NULL) SWIG_fail;
11359 temp1 = true;
11360 }
11361 {
11362 PyThreadState* __tstate = wxPyBeginAllowThreads();
11363 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11364 wxPyEndAllowThreads(__tstate);
11365 if (PyErr_Occurred()) SWIG_fail;
11366 }
11367 resultobj = SWIG_Py_Void();
11368 {
11369 if (temp1)
11370 delete arg1;
11371 }
11372 return resultobj;
11373 fail:
11374 {
11375 if (temp1)
11376 delete arg1;
11377 }
11378 return NULL;
11379 }
11380
11381
11382 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11383 PyObject *resultobj = 0;
11384 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11385 wxString *arg2 = 0 ;
11386 bool result;
11387 void *argp1 = 0 ;
11388 int res1 = 0 ;
11389 bool temp2 = false ;
11390 PyObject * obj0 = 0 ;
11391 PyObject * obj1 = 0 ;
11392 char * kwnames[] = {
11393 (char *) "self",(char *) "location", NULL
11394 };
11395
11396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11398 if (!SWIG_IsOK(res1)) {
11399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11400 }
11401 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11402 {
11403 arg2 = wxString_in_helper(obj1);
11404 if (arg2 == NULL) SWIG_fail;
11405 temp2 = true;
11406 }
11407 {
11408 PyThreadState* __tstate = wxPyBeginAllowThreads();
11409 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11410 wxPyEndAllowThreads(__tstate);
11411 if (PyErr_Occurred()) SWIG_fail;
11412 }
11413 {
11414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11415 }
11416 {
11417 if (temp2)
11418 delete arg2;
11419 }
11420 return resultobj;
11421 fail:
11422 {
11423 if (temp2)
11424 delete arg2;
11425 }
11426 return NULL;
11427 }
11428
11429
11430 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11431 PyObject *resultobj = 0;
11432 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11433 wxFileSystem *arg2 = 0 ;
11434 wxString *arg3 = 0 ;
11435 wxFSFile *result = 0 ;
11436 void *argp1 = 0 ;
11437 int res1 = 0 ;
11438 void *argp2 = 0 ;
11439 int res2 = 0 ;
11440 bool temp3 = false ;
11441 PyObject * obj0 = 0 ;
11442 PyObject * obj1 = 0 ;
11443 PyObject * obj2 = 0 ;
11444 char * kwnames[] = {
11445 (char *) "self",(char *) "fs",(char *) "location", NULL
11446 };
11447
11448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11450 if (!SWIG_IsOK(res1)) {
11451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11452 }
11453 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11454 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11455 if (!SWIG_IsOK(res2)) {
11456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11457 }
11458 if (!argp2) {
11459 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11460 }
11461 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11462 {
11463 arg3 = wxString_in_helper(obj2);
11464 if (arg3 == NULL) SWIG_fail;
11465 temp3 = true;
11466 }
11467 {
11468 PyThreadState* __tstate = wxPyBeginAllowThreads();
11469 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11470 wxPyEndAllowThreads(__tstate);
11471 if (PyErr_Occurred()) SWIG_fail;
11472 }
11473 {
11474 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11475 }
11476 {
11477 if (temp3)
11478 delete arg3;
11479 }
11480 return resultobj;
11481 fail:
11482 {
11483 if (temp3)
11484 delete arg3;
11485 }
11486 return NULL;
11487 }
11488
11489
11490 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11491 PyObject *resultobj = 0;
11492 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11493 wxString *arg2 = 0 ;
11494 int arg3 = (int) 0 ;
11495 wxString result;
11496 void *argp1 = 0 ;
11497 int res1 = 0 ;
11498 bool temp2 = false ;
11499 int val3 ;
11500 int ecode3 = 0 ;
11501 PyObject * obj0 = 0 ;
11502 PyObject * obj1 = 0 ;
11503 PyObject * obj2 = 0 ;
11504 char * kwnames[] = {
11505 (char *) "self",(char *) "spec",(char *) "flags", NULL
11506 };
11507
11508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11510 if (!SWIG_IsOK(res1)) {
11511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11512 }
11513 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11514 {
11515 arg2 = wxString_in_helper(obj1);
11516 if (arg2 == NULL) SWIG_fail;
11517 temp2 = true;
11518 }
11519 if (obj2) {
11520 ecode3 = SWIG_AsVal_int(obj2, &val3);
11521 if (!SWIG_IsOK(ecode3)) {
11522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11523 }
11524 arg3 = static_cast< int >(val3);
11525 }
11526 {
11527 PyThreadState* __tstate = wxPyBeginAllowThreads();
11528 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11529 wxPyEndAllowThreads(__tstate);
11530 if (PyErr_Occurred()) SWIG_fail;
11531 }
11532 {
11533 #if wxUSE_UNICODE
11534 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11535 #else
11536 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11537 #endif
11538 }
11539 {
11540 if (temp2)
11541 delete arg2;
11542 }
11543 return resultobj;
11544 fail:
11545 {
11546 if (temp2)
11547 delete arg2;
11548 }
11549 return NULL;
11550 }
11551
11552
11553 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11554 PyObject *resultobj = 0;
11555 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11556 wxString result;
11557 void *argp1 = 0 ;
11558 int res1 = 0 ;
11559 PyObject *swig_obj[1] ;
11560
11561 if (!args) SWIG_fail;
11562 swig_obj[0] = args;
11563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11564 if (!SWIG_IsOK(res1)) {
11565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11566 }
11567 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11568 {
11569 PyThreadState* __tstate = wxPyBeginAllowThreads();
11570 result = (arg1)->FindNext();
11571 wxPyEndAllowThreads(__tstate);
11572 if (PyErr_Occurred()) SWIG_fail;
11573 }
11574 {
11575 #if wxUSE_UNICODE
11576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11577 #else
11578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11579 #endif
11580 }
11581 return resultobj;
11582 fail:
11583 return NULL;
11584 }
11585
11586
11587 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11588 PyObject *obj;
11589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11590 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11591 return SWIG_Py_Void();
11592 }
11593
11594 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11595 return SWIG_Python_InitShadowInstance(args);
11596 }
11597
11598 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11599 PyObject *resultobj = 0;
11600 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11601 wxString result;
11602 void *argp1 = 0 ;
11603 int res1 = 0 ;
11604 PyObject *swig_obj[1] ;
11605
11606 if (!args) SWIG_fail;
11607 swig_obj[0] = args;
11608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11609 if (!SWIG_IsOK(res1)) {
11610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11611 }
11612 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11613 {
11614 PyThreadState* __tstate = wxPyBeginAllowThreads();
11615 result = (arg1)->GetName();
11616 wxPyEndAllowThreads(__tstate);
11617 if (PyErr_Occurred()) SWIG_fail;
11618 }
11619 {
11620 #if wxUSE_UNICODE
11621 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11622 #else
11623 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11624 #endif
11625 }
11626 return resultobj;
11627 fail:
11628 return NULL;
11629 }
11630
11631
11632 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11633 PyObject *resultobj = 0;
11634 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11635 wxString result;
11636 void *argp1 = 0 ;
11637 int res1 = 0 ;
11638 PyObject *swig_obj[1] ;
11639
11640 if (!args) SWIG_fail;
11641 swig_obj[0] = args;
11642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11643 if (!SWIG_IsOK(res1)) {
11644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11645 }
11646 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11647 {
11648 PyThreadState* __tstate = wxPyBeginAllowThreads();
11649 result = (arg1)->GetExtension();
11650 wxPyEndAllowThreads(__tstate);
11651 if (PyErr_Occurred()) SWIG_fail;
11652 }
11653 {
11654 #if wxUSE_UNICODE
11655 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11656 #else
11657 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11658 #endif
11659 }
11660 return resultobj;
11661 fail:
11662 return NULL;
11663 }
11664
11665
11666 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11667 PyObject *resultobj = 0;
11668 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11669 long result;
11670 void *argp1 = 0 ;
11671 int res1 = 0 ;
11672 PyObject *swig_obj[1] ;
11673
11674 if (!args) SWIG_fail;
11675 swig_obj[0] = args;
11676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11677 if (!SWIG_IsOK(res1)) {
11678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11679 }
11680 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11681 {
11682 PyThreadState* __tstate = wxPyBeginAllowThreads();
11683 result = (long)(arg1)->GetType();
11684 wxPyEndAllowThreads(__tstate);
11685 if (PyErr_Occurred()) SWIG_fail;
11686 }
11687 resultobj = SWIG_From_long(static_cast< long >(result));
11688 return resultobj;
11689 fail:
11690 return NULL;
11691 }
11692
11693
11694 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11695 PyObject *resultobj = 0;
11696 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11697 wxString result;
11698 void *argp1 = 0 ;
11699 int res1 = 0 ;
11700 PyObject *swig_obj[1] ;
11701
11702 if (!args) SWIG_fail;
11703 swig_obj[0] = args;
11704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11705 if (!SWIG_IsOK(res1)) {
11706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11707 }
11708 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (arg1)->GetMimeType();
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 {
11716 #if wxUSE_UNICODE
11717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11718 #else
11719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11720 #endif
11721 }
11722 return resultobj;
11723 fail:
11724 return NULL;
11725 }
11726
11727
11728 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11729 PyObject *resultobj = 0;
11730 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11731 wxString *arg2 = 0 ;
11732 bool result;
11733 void *argp1 = 0 ;
11734 int res1 = 0 ;
11735 bool temp2 = false ;
11736 PyObject * obj0 = 0 ;
11737 PyObject * obj1 = 0 ;
11738 char * kwnames[] = {
11739 (char *) "self",(char *) "name", NULL
11740 };
11741
11742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11744 if (!SWIG_IsOK(res1)) {
11745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11746 }
11747 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11748 {
11749 arg2 = wxString_in_helper(obj1);
11750 if (arg2 == NULL) SWIG_fail;
11751 temp2 = true;
11752 }
11753 {
11754 PyThreadState* __tstate = wxPyBeginAllowThreads();
11755 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11756 wxPyEndAllowThreads(__tstate);
11757 if (PyErr_Occurred()) SWIG_fail;
11758 }
11759 {
11760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11761 }
11762 {
11763 if (temp2)
11764 delete arg2;
11765 }
11766 return resultobj;
11767 fail:
11768 {
11769 if (temp2)
11770 delete arg2;
11771 }
11772 return NULL;
11773 }
11774
11775
11776 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11777 PyObject *resultobj = 0;
11778 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11779 wxString *arg2 = 0 ;
11780 void *argp1 = 0 ;
11781 int res1 = 0 ;
11782 bool temp2 = false ;
11783 PyObject * obj0 = 0 ;
11784 PyObject * obj1 = 0 ;
11785 char * kwnames[] = {
11786 (char *) "self",(char *) "name", NULL
11787 };
11788
11789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11791 if (!SWIG_IsOK(res1)) {
11792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11793 }
11794 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11795 {
11796 arg2 = wxString_in_helper(obj1);
11797 if (arg2 == NULL) SWIG_fail;
11798 temp2 = true;
11799 }
11800 {
11801 PyThreadState* __tstate = wxPyBeginAllowThreads();
11802 (arg1)->SetName((wxString const &)*arg2);
11803 wxPyEndAllowThreads(__tstate);
11804 if (PyErr_Occurred()) SWIG_fail;
11805 }
11806 resultobj = SWIG_Py_Void();
11807 {
11808 if (temp2)
11809 delete arg2;
11810 }
11811 return resultobj;
11812 fail:
11813 {
11814 if (temp2)
11815 delete arg2;
11816 }
11817 return NULL;
11818 }
11819
11820
11821 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11822 PyObject *resultobj = 0;
11823 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11824 wxString *arg2 = 0 ;
11825 void *argp1 = 0 ;
11826 int res1 = 0 ;
11827 bool temp2 = false ;
11828 PyObject * obj0 = 0 ;
11829 PyObject * obj1 = 0 ;
11830 char * kwnames[] = {
11831 (char *) "self",(char *) "extension", NULL
11832 };
11833
11834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11836 if (!SWIG_IsOK(res1)) {
11837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11838 }
11839 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11840 {
11841 arg2 = wxString_in_helper(obj1);
11842 if (arg2 == NULL) SWIG_fail;
11843 temp2 = true;
11844 }
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 (arg1)->SetExtension((wxString const &)*arg2);
11848 wxPyEndAllowThreads(__tstate);
11849 if (PyErr_Occurred()) SWIG_fail;
11850 }
11851 resultobj = SWIG_Py_Void();
11852 {
11853 if (temp2)
11854 delete arg2;
11855 }
11856 return resultobj;
11857 fail:
11858 {
11859 if (temp2)
11860 delete arg2;
11861 }
11862 return NULL;
11863 }
11864
11865
11866 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11867 PyObject *resultobj = 0;
11868 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11869 long arg2 ;
11870 void *argp1 = 0 ;
11871 int res1 = 0 ;
11872 long val2 ;
11873 int ecode2 = 0 ;
11874 PyObject * obj0 = 0 ;
11875 PyObject * obj1 = 0 ;
11876 char * kwnames[] = {
11877 (char *) "self",(char *) "type", NULL
11878 };
11879
11880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11882 if (!SWIG_IsOK(res1)) {
11883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11884 }
11885 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11886 ecode2 = SWIG_AsVal_long(obj1, &val2);
11887 if (!SWIG_IsOK(ecode2)) {
11888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11889 }
11890 arg2 = static_cast< long >(val2);
11891 {
11892 PyThreadState* __tstate = wxPyBeginAllowThreads();
11893 (arg1)->SetType(arg2);
11894 wxPyEndAllowThreads(__tstate);
11895 if (PyErr_Occurred()) SWIG_fail;
11896 }
11897 resultobj = SWIG_Py_Void();
11898 return resultobj;
11899 fail:
11900 return NULL;
11901 }
11902
11903
11904 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11905 PyObject *resultobj = 0;
11906 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11907 wxString *arg2 = 0 ;
11908 void *argp1 = 0 ;
11909 int res1 = 0 ;
11910 bool temp2 = false ;
11911 PyObject * obj0 = 0 ;
11912 PyObject * obj1 = 0 ;
11913 char * kwnames[] = {
11914 (char *) "self",(char *) "mimetype", NULL
11915 };
11916
11917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11919 if (!SWIG_IsOK(res1)) {
11920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11921 }
11922 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11923 {
11924 arg2 = wxString_in_helper(obj1);
11925 if (arg2 == NULL) SWIG_fail;
11926 temp2 = true;
11927 }
11928 {
11929 PyThreadState* __tstate = wxPyBeginAllowThreads();
11930 (arg1)->SetMimeType((wxString const &)*arg2);
11931 wxPyEndAllowThreads(__tstate);
11932 if (PyErr_Occurred()) SWIG_fail;
11933 }
11934 resultobj = SWIG_Py_Void();
11935 {
11936 if (temp2)
11937 delete arg2;
11938 }
11939 return resultobj;
11940 fail:
11941 {
11942 if (temp2)
11943 delete arg2;
11944 }
11945 return NULL;
11946 }
11947
11948
11949 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11950 PyObject *obj;
11951 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11952 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
11953 return SWIG_Py_Void();
11954 }
11955
11956 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11957 PyObject *resultobj = 0;
11958 wxPyImageHandler *result = 0 ;
11959
11960 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
11961 {
11962 PyThreadState* __tstate = wxPyBeginAllowThreads();
11963 result = (wxPyImageHandler *)new wxPyImageHandler();
11964 wxPyEndAllowThreads(__tstate);
11965 if (PyErr_Occurred()) SWIG_fail;
11966 }
11967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
11968 return resultobj;
11969 fail:
11970 return NULL;
11971 }
11972
11973
11974 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11975 PyObject *resultobj = 0;
11976 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
11977 PyObject *arg2 = (PyObject *) 0 ;
11978 void *argp1 = 0 ;
11979 int res1 = 0 ;
11980 PyObject * obj0 = 0 ;
11981 PyObject * obj1 = 0 ;
11982 char * kwnames[] = {
11983 (char *) "self",(char *) "self", NULL
11984 };
11985
11986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
11987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
11988 if (!SWIG_IsOK(res1)) {
11989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
11990 }
11991 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
11992 arg2 = obj1;
11993 {
11994 PyThreadState* __tstate = wxPyBeginAllowThreads();
11995 (arg1)->_SetSelf(arg2);
11996 wxPyEndAllowThreads(__tstate);
11997 if (PyErr_Occurred()) SWIG_fail;
11998 }
11999 resultobj = SWIG_Py_Void();
12000 return resultobj;
12001 fail:
12002 return NULL;
12003 }
12004
12005
12006 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12007 PyObject *obj;
12008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12009 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12010 return SWIG_Py_Void();
12011 }
12012
12013 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12014 return SWIG_Python_InitShadowInstance(args);
12015 }
12016
12017 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12018 PyObject *resultobj = 0;
12019 wxImageHistogram *result = 0 ;
12020
12021 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12022 {
12023 PyThreadState* __tstate = wxPyBeginAllowThreads();
12024 result = (wxImageHistogram *)new wxImageHistogram();
12025 wxPyEndAllowThreads(__tstate);
12026 if (PyErr_Occurred()) SWIG_fail;
12027 }
12028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12029 return resultobj;
12030 fail:
12031 return NULL;
12032 }
12033
12034
12035 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12036 PyObject *resultobj = 0;
12037 byte arg1 ;
12038 byte arg2 ;
12039 byte arg3 ;
12040 unsigned long result;
12041 unsigned char val1 ;
12042 int ecode1 = 0 ;
12043 unsigned char val2 ;
12044 int ecode2 = 0 ;
12045 unsigned char val3 ;
12046 int ecode3 = 0 ;
12047 PyObject * obj0 = 0 ;
12048 PyObject * obj1 = 0 ;
12049 PyObject * obj2 = 0 ;
12050 char * kwnames[] = {
12051 (char *) "r",(char *) "g",(char *) "b", NULL
12052 };
12053
12054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12055 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12056 if (!SWIG_IsOK(ecode1)) {
12057 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12058 }
12059 arg1 = static_cast< byte >(val1);
12060 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12061 if (!SWIG_IsOK(ecode2)) {
12062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12063 }
12064 arg2 = static_cast< byte >(val2);
12065 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12066 if (!SWIG_IsOK(ecode3)) {
12067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12068 }
12069 arg3 = static_cast< byte >(val3);
12070 {
12071 PyThreadState* __tstate = wxPyBeginAllowThreads();
12072 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12073 wxPyEndAllowThreads(__tstate);
12074 if (PyErr_Occurred()) SWIG_fail;
12075 }
12076 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12077 return resultobj;
12078 fail:
12079 return NULL;
12080 }
12081
12082
12083 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12084 PyObject *resultobj = 0;
12085 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12086 byte *arg2 = (byte *) 0 ;
12087 byte *arg3 = (byte *) 0 ;
12088 byte *arg4 = (byte *) 0 ;
12089 byte arg5 = (byte) 1 ;
12090 byte arg6 = (byte) 0 ;
12091 byte arg7 = (byte) 0 ;
12092 bool result;
12093 void *argp1 = 0 ;
12094 int res1 = 0 ;
12095 byte temp2 ;
12096 int res2 = SWIG_TMPOBJ ;
12097 byte temp3 ;
12098 int res3 = SWIG_TMPOBJ ;
12099 byte temp4 ;
12100 int res4 = SWIG_TMPOBJ ;
12101 unsigned char val5 ;
12102 int ecode5 = 0 ;
12103 unsigned char val6 ;
12104 int ecode6 = 0 ;
12105 unsigned char val7 ;
12106 int ecode7 = 0 ;
12107 PyObject * obj0 = 0 ;
12108 PyObject * obj1 = 0 ;
12109 PyObject * obj2 = 0 ;
12110 PyObject * obj3 = 0 ;
12111 char * kwnames[] = {
12112 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12113 };
12114
12115 arg2 = &temp2;
12116 arg3 = &temp3;
12117 arg4 = &temp4;
12118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12120 if (!SWIG_IsOK(res1)) {
12121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12122 }
12123 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12124 if (obj1) {
12125 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12126 if (!SWIG_IsOK(ecode5)) {
12127 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12128 }
12129 arg5 = static_cast< byte >(val5);
12130 }
12131 if (obj2) {
12132 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12133 if (!SWIG_IsOK(ecode6)) {
12134 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12135 }
12136 arg6 = static_cast< byte >(val6);
12137 }
12138 if (obj3) {
12139 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12140 if (!SWIG_IsOK(ecode7)) {
12141 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12142 }
12143 arg7 = static_cast< byte >(val7);
12144 }
12145 {
12146 PyThreadState* __tstate = wxPyBeginAllowThreads();
12147 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12148 wxPyEndAllowThreads(__tstate);
12149 if (PyErr_Occurred()) SWIG_fail;
12150 }
12151 {
12152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12153 }
12154 if (SWIG_IsTmpObj(res2)) {
12155 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12156 } else {
12157 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12158 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12159 }
12160 if (SWIG_IsTmpObj(res3)) {
12161 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12162 } else {
12163 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12164 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12165 }
12166 if (SWIG_IsTmpObj(res4)) {
12167 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12168 } else {
12169 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12170 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12171 }
12172 return resultobj;
12173 fail:
12174 return NULL;
12175 }
12176
12177
12178 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12179 PyObject *resultobj = 0;
12180 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12181 unsigned long arg2 ;
12182 unsigned long result;
12183 void *argp1 = 0 ;
12184 int res1 = 0 ;
12185 unsigned long val2 ;
12186 int ecode2 = 0 ;
12187 PyObject * obj0 = 0 ;
12188 PyObject * obj1 = 0 ;
12189 char * kwnames[] = {
12190 (char *) "self",(char *) "key", NULL
12191 };
12192
12193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12195 if (!SWIG_IsOK(res1)) {
12196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12197 }
12198 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12199 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12200 if (!SWIG_IsOK(ecode2)) {
12201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12202 }
12203 arg2 = static_cast< unsigned long >(val2);
12204 {
12205 PyThreadState* __tstate = wxPyBeginAllowThreads();
12206 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12207 wxPyEndAllowThreads(__tstate);
12208 if (PyErr_Occurred()) SWIG_fail;
12209 }
12210 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12218 PyObject *resultobj = 0;
12219 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12220 byte arg2 ;
12221 byte arg3 ;
12222 byte arg4 ;
12223 unsigned long result;
12224 void *argp1 = 0 ;
12225 int res1 = 0 ;
12226 unsigned char val2 ;
12227 int ecode2 = 0 ;
12228 unsigned char val3 ;
12229 int ecode3 = 0 ;
12230 unsigned char val4 ;
12231 int ecode4 = 0 ;
12232 PyObject * obj0 = 0 ;
12233 PyObject * obj1 = 0 ;
12234 PyObject * obj2 = 0 ;
12235 PyObject * obj3 = 0 ;
12236 char * kwnames[] = {
12237 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12238 };
12239
12240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12242 if (!SWIG_IsOK(res1)) {
12243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12244 }
12245 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12246 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12247 if (!SWIG_IsOK(ecode2)) {
12248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12249 }
12250 arg2 = static_cast< byte >(val2);
12251 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12252 if (!SWIG_IsOK(ecode3)) {
12253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12254 }
12255 arg3 = static_cast< byte >(val3);
12256 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12257 if (!SWIG_IsOK(ecode4)) {
12258 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12259 }
12260 arg4 = static_cast< byte >(val4);
12261 {
12262 PyThreadState* __tstate = wxPyBeginAllowThreads();
12263 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12264 wxPyEndAllowThreads(__tstate);
12265 if (PyErr_Occurred()) SWIG_fail;
12266 }
12267 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12268 return resultobj;
12269 fail:
12270 return NULL;
12271 }
12272
12273
12274 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12275 PyObject *resultobj = 0;
12276 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12277 wxColour *arg2 = 0 ;
12278 unsigned long result;
12279 void *argp1 = 0 ;
12280 int res1 = 0 ;
12281 wxColour temp2 ;
12282 PyObject * obj0 = 0 ;
12283 PyObject * obj1 = 0 ;
12284 char * kwnames[] = {
12285 (char *) "self",(char *) "colour", NULL
12286 };
12287
12288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12290 if (!SWIG_IsOK(res1)) {
12291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12292 }
12293 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12294 {
12295 arg2 = &temp2;
12296 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12297 }
12298 {
12299 PyThreadState* __tstate = wxPyBeginAllowThreads();
12300 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12301 wxPyEndAllowThreads(__tstate);
12302 if (PyErr_Occurred()) SWIG_fail;
12303 }
12304 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12312 PyObject *obj;
12313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12314 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12315 return SWIG_Py_Void();
12316 }
12317
12318 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12319 return SWIG_Python_InitShadowInstance(args);
12320 }
12321
12322 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12323 PyObject *resultobj = 0;
12324 byte arg1 = (byte) 0 ;
12325 byte arg2 = (byte) 0 ;
12326 byte arg3 = (byte) 0 ;
12327 wxImage_RGBValue *result = 0 ;
12328 unsigned char val1 ;
12329 int ecode1 = 0 ;
12330 unsigned char val2 ;
12331 int ecode2 = 0 ;
12332 unsigned char val3 ;
12333 int ecode3 = 0 ;
12334 PyObject * obj0 = 0 ;
12335 PyObject * obj1 = 0 ;
12336 PyObject * obj2 = 0 ;
12337 char * kwnames[] = {
12338 (char *) "r",(char *) "g",(char *) "b", NULL
12339 };
12340
12341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12342 if (obj0) {
12343 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12344 if (!SWIG_IsOK(ecode1)) {
12345 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12346 }
12347 arg1 = static_cast< byte >(val1);
12348 }
12349 if (obj1) {
12350 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12351 if (!SWIG_IsOK(ecode2)) {
12352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12353 }
12354 arg2 = static_cast< byte >(val2);
12355 }
12356 if (obj2) {
12357 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12358 if (!SWIG_IsOK(ecode3)) {
12359 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12360 }
12361 arg3 = static_cast< byte >(val3);
12362 }
12363 {
12364 PyThreadState* __tstate = wxPyBeginAllowThreads();
12365 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12366 wxPyEndAllowThreads(__tstate);
12367 if (PyErr_Occurred()) SWIG_fail;
12368 }
12369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12370 return resultobj;
12371 fail:
12372 return NULL;
12373 }
12374
12375
12376 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12377 PyObject *resultobj = 0;
12378 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12379 byte arg2 ;
12380 void *argp1 = 0 ;
12381 int res1 = 0 ;
12382 unsigned char val2 ;
12383 int ecode2 = 0 ;
12384 PyObject *swig_obj[2] ;
12385
12386 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12388 if (!SWIG_IsOK(res1)) {
12389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12390 }
12391 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12392 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12393 if (!SWIG_IsOK(ecode2)) {
12394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12395 }
12396 arg2 = static_cast< byte >(val2);
12397 if (arg1) (arg1)->red = arg2;
12398
12399 resultobj = SWIG_Py_Void();
12400 return resultobj;
12401 fail:
12402 return NULL;
12403 }
12404
12405
12406 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12407 PyObject *resultobj = 0;
12408 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12409 byte result;
12410 void *argp1 = 0 ;
12411 int res1 = 0 ;
12412 PyObject *swig_obj[1] ;
12413
12414 if (!args) SWIG_fail;
12415 swig_obj[0] = args;
12416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12417 if (!SWIG_IsOK(res1)) {
12418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12419 }
12420 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12421 result = (byte) ((arg1)->red);
12422 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12423 return resultobj;
12424 fail:
12425 return NULL;
12426 }
12427
12428
12429 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12430 PyObject *resultobj = 0;
12431 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12432 byte arg2 ;
12433 void *argp1 = 0 ;
12434 int res1 = 0 ;
12435 unsigned char val2 ;
12436 int ecode2 = 0 ;
12437 PyObject *swig_obj[2] ;
12438
12439 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12441 if (!SWIG_IsOK(res1)) {
12442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12443 }
12444 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12445 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12446 if (!SWIG_IsOK(ecode2)) {
12447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12448 }
12449 arg2 = static_cast< byte >(val2);
12450 if (arg1) (arg1)->green = arg2;
12451
12452 resultobj = SWIG_Py_Void();
12453 return resultobj;
12454 fail:
12455 return NULL;
12456 }
12457
12458
12459 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12460 PyObject *resultobj = 0;
12461 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12462 byte result;
12463 void *argp1 = 0 ;
12464 int res1 = 0 ;
12465 PyObject *swig_obj[1] ;
12466
12467 if (!args) SWIG_fail;
12468 swig_obj[0] = args;
12469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12470 if (!SWIG_IsOK(res1)) {
12471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12472 }
12473 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12474 result = (byte) ((arg1)->green);
12475 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12476 return resultobj;
12477 fail:
12478 return NULL;
12479 }
12480
12481
12482 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12483 PyObject *resultobj = 0;
12484 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12485 byte arg2 ;
12486 void *argp1 = 0 ;
12487 int res1 = 0 ;
12488 unsigned char val2 ;
12489 int ecode2 = 0 ;
12490 PyObject *swig_obj[2] ;
12491
12492 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12494 if (!SWIG_IsOK(res1)) {
12495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12496 }
12497 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12498 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12499 if (!SWIG_IsOK(ecode2)) {
12500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12501 }
12502 arg2 = static_cast< byte >(val2);
12503 if (arg1) (arg1)->blue = arg2;
12504
12505 resultobj = SWIG_Py_Void();
12506 return resultobj;
12507 fail:
12508 return NULL;
12509 }
12510
12511
12512 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12513 PyObject *resultobj = 0;
12514 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12515 byte result;
12516 void *argp1 = 0 ;
12517 int res1 = 0 ;
12518 PyObject *swig_obj[1] ;
12519
12520 if (!args) SWIG_fail;
12521 swig_obj[0] = args;
12522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12523 if (!SWIG_IsOK(res1)) {
12524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12525 }
12526 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12527 result = (byte) ((arg1)->blue);
12528 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12529 return resultobj;
12530 fail:
12531 return NULL;
12532 }
12533
12534
12535 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12536 PyObject *obj;
12537 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12538 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12539 return SWIG_Py_Void();
12540 }
12541
12542 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12543 return SWIG_Python_InitShadowInstance(args);
12544 }
12545
12546 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12547 PyObject *resultobj = 0;
12548 double arg1 = (double) 0.0 ;
12549 double arg2 = (double) 0.0 ;
12550 double arg3 = (double) 0.0 ;
12551 wxImage_HSVValue *result = 0 ;
12552 double val1 ;
12553 int ecode1 = 0 ;
12554 double val2 ;
12555 int ecode2 = 0 ;
12556 double val3 ;
12557 int ecode3 = 0 ;
12558 PyObject * obj0 = 0 ;
12559 PyObject * obj1 = 0 ;
12560 PyObject * obj2 = 0 ;
12561 char * kwnames[] = {
12562 (char *) "h",(char *) "s",(char *) "v", NULL
12563 };
12564
12565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12566 if (obj0) {
12567 ecode1 = SWIG_AsVal_double(obj0, &val1);
12568 if (!SWIG_IsOK(ecode1)) {
12569 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12570 }
12571 arg1 = static_cast< double >(val1);
12572 }
12573 if (obj1) {
12574 ecode2 = SWIG_AsVal_double(obj1, &val2);
12575 if (!SWIG_IsOK(ecode2)) {
12576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12577 }
12578 arg2 = static_cast< double >(val2);
12579 }
12580 if (obj2) {
12581 ecode3 = SWIG_AsVal_double(obj2, &val3);
12582 if (!SWIG_IsOK(ecode3)) {
12583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12584 }
12585 arg3 = static_cast< double >(val3);
12586 }
12587 {
12588 PyThreadState* __tstate = wxPyBeginAllowThreads();
12589 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12590 wxPyEndAllowThreads(__tstate);
12591 if (PyErr_Occurred()) SWIG_fail;
12592 }
12593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12594 return resultobj;
12595 fail:
12596 return NULL;
12597 }
12598
12599
12600 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12601 PyObject *resultobj = 0;
12602 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12603 double arg2 ;
12604 void *argp1 = 0 ;
12605 int res1 = 0 ;
12606 double val2 ;
12607 int ecode2 = 0 ;
12608 PyObject *swig_obj[2] ;
12609
12610 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12612 if (!SWIG_IsOK(res1)) {
12613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12614 }
12615 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12616 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12617 if (!SWIG_IsOK(ecode2)) {
12618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12619 }
12620 arg2 = static_cast< double >(val2);
12621 if (arg1) (arg1)->hue = arg2;
12622
12623 resultobj = SWIG_Py_Void();
12624 return resultobj;
12625 fail:
12626 return NULL;
12627 }
12628
12629
12630 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12631 PyObject *resultobj = 0;
12632 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12633 double result;
12634 void *argp1 = 0 ;
12635 int res1 = 0 ;
12636 PyObject *swig_obj[1] ;
12637
12638 if (!args) SWIG_fail;
12639 swig_obj[0] = args;
12640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12641 if (!SWIG_IsOK(res1)) {
12642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12643 }
12644 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12645 result = (double) ((arg1)->hue);
12646 resultobj = SWIG_From_double(static_cast< double >(result));
12647 return resultobj;
12648 fail:
12649 return NULL;
12650 }
12651
12652
12653 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12654 PyObject *resultobj = 0;
12655 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12656 double arg2 ;
12657 void *argp1 = 0 ;
12658 int res1 = 0 ;
12659 double val2 ;
12660 int ecode2 = 0 ;
12661 PyObject *swig_obj[2] ;
12662
12663 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12665 if (!SWIG_IsOK(res1)) {
12666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12667 }
12668 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12669 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12670 if (!SWIG_IsOK(ecode2)) {
12671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12672 }
12673 arg2 = static_cast< double >(val2);
12674 if (arg1) (arg1)->saturation = arg2;
12675
12676 resultobj = SWIG_Py_Void();
12677 return resultobj;
12678 fail:
12679 return NULL;
12680 }
12681
12682
12683 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12684 PyObject *resultobj = 0;
12685 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12686 double result;
12687 void *argp1 = 0 ;
12688 int res1 = 0 ;
12689 PyObject *swig_obj[1] ;
12690
12691 if (!args) SWIG_fail;
12692 swig_obj[0] = args;
12693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12694 if (!SWIG_IsOK(res1)) {
12695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12696 }
12697 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12698 result = (double) ((arg1)->saturation);
12699 resultobj = SWIG_From_double(static_cast< double >(result));
12700 return resultobj;
12701 fail:
12702 return NULL;
12703 }
12704
12705
12706 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12707 PyObject *resultobj = 0;
12708 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12709 double arg2 ;
12710 void *argp1 = 0 ;
12711 int res1 = 0 ;
12712 double val2 ;
12713 int ecode2 = 0 ;
12714 PyObject *swig_obj[2] ;
12715
12716 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12718 if (!SWIG_IsOK(res1)) {
12719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12720 }
12721 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12722 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12723 if (!SWIG_IsOK(ecode2)) {
12724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12725 }
12726 arg2 = static_cast< double >(val2);
12727 if (arg1) (arg1)->value = arg2;
12728
12729 resultobj = SWIG_Py_Void();
12730 return resultobj;
12731 fail:
12732 return NULL;
12733 }
12734
12735
12736 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12737 PyObject *resultobj = 0;
12738 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12739 double result;
12740 void *argp1 = 0 ;
12741 int res1 = 0 ;
12742 PyObject *swig_obj[1] ;
12743
12744 if (!args) SWIG_fail;
12745 swig_obj[0] = args;
12746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12747 if (!SWIG_IsOK(res1)) {
12748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12749 }
12750 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12751 result = (double) ((arg1)->value);
12752 resultobj = SWIG_From_double(static_cast< double >(result));
12753 return resultobj;
12754 fail:
12755 return NULL;
12756 }
12757
12758
12759 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12760 PyObject *obj;
12761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12762 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12763 return SWIG_Py_Void();
12764 }
12765
12766 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12767 return SWIG_Python_InitShadowInstance(args);
12768 }
12769
12770 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12771 PyObject *resultobj = 0;
12772 wxString *arg1 = 0 ;
12773 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12774 int arg3 = (int) -1 ;
12775 wxImage *result = 0 ;
12776 bool temp1 = false ;
12777 long val2 ;
12778 int ecode2 = 0 ;
12779 int val3 ;
12780 int ecode3 = 0 ;
12781 PyObject * obj0 = 0 ;
12782 PyObject * obj1 = 0 ;
12783 PyObject * obj2 = 0 ;
12784 char * kwnames[] = {
12785 (char *) "name",(char *) "type",(char *) "index", NULL
12786 };
12787
12788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12789 {
12790 arg1 = wxString_in_helper(obj0);
12791 if (arg1 == NULL) SWIG_fail;
12792 temp1 = true;
12793 }
12794 if (obj1) {
12795 ecode2 = SWIG_AsVal_long(obj1, &val2);
12796 if (!SWIG_IsOK(ecode2)) {
12797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12798 }
12799 arg2 = static_cast< long >(val2);
12800 }
12801 if (obj2) {
12802 ecode3 = SWIG_AsVal_int(obj2, &val3);
12803 if (!SWIG_IsOK(ecode3)) {
12804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12805 }
12806 arg3 = static_cast< int >(val3);
12807 }
12808 {
12809 PyThreadState* __tstate = wxPyBeginAllowThreads();
12810 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12811 wxPyEndAllowThreads(__tstate);
12812 if (PyErr_Occurred()) SWIG_fail;
12813 }
12814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12815 {
12816 if (temp1)
12817 delete arg1;
12818 }
12819 return resultobj;
12820 fail:
12821 {
12822 if (temp1)
12823 delete arg1;
12824 }
12825 return NULL;
12826 }
12827
12828
12829 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12830 PyObject *resultobj = 0;
12831 wxImage *arg1 = (wxImage *) 0 ;
12832 void *argp1 = 0 ;
12833 int res1 = 0 ;
12834 PyObject *swig_obj[1] ;
12835
12836 if (!args) SWIG_fail;
12837 swig_obj[0] = args;
12838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12839 if (!SWIG_IsOK(res1)) {
12840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12841 }
12842 arg1 = reinterpret_cast< wxImage * >(argp1);
12843 {
12844 PyThreadState* __tstate = wxPyBeginAllowThreads();
12845 delete arg1;
12846
12847 wxPyEndAllowThreads(__tstate);
12848 if (PyErr_Occurred()) SWIG_fail;
12849 }
12850 resultobj = SWIG_Py_Void();
12851 return resultobj;
12852 fail:
12853 return NULL;
12854 }
12855
12856
12857 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12858 PyObject *resultobj = 0;
12859 wxString *arg1 = 0 ;
12860 wxString *arg2 = 0 ;
12861 int arg3 = (int) -1 ;
12862 wxImage *result = 0 ;
12863 bool temp1 = false ;
12864 bool temp2 = false ;
12865 int val3 ;
12866 int ecode3 = 0 ;
12867 PyObject * obj0 = 0 ;
12868 PyObject * obj1 = 0 ;
12869 PyObject * obj2 = 0 ;
12870 char * kwnames[] = {
12871 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12872 };
12873
12874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12875 {
12876 arg1 = wxString_in_helper(obj0);
12877 if (arg1 == NULL) SWIG_fail;
12878 temp1 = true;
12879 }
12880 {
12881 arg2 = wxString_in_helper(obj1);
12882 if (arg2 == NULL) SWIG_fail;
12883 temp2 = true;
12884 }
12885 if (obj2) {
12886 ecode3 = SWIG_AsVal_int(obj2, &val3);
12887 if (!SWIG_IsOK(ecode3)) {
12888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12889 }
12890 arg3 = static_cast< int >(val3);
12891 }
12892 {
12893 PyThreadState* __tstate = wxPyBeginAllowThreads();
12894 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12899 {
12900 if (temp1)
12901 delete arg1;
12902 }
12903 {
12904 if (temp2)
12905 delete arg2;
12906 }
12907 return resultobj;
12908 fail:
12909 {
12910 if (temp1)
12911 delete arg1;
12912 }
12913 {
12914 if (temp2)
12915 delete arg2;
12916 }
12917 return NULL;
12918 }
12919
12920
12921 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12922 PyObject *resultobj = 0;
12923 wxInputStream *arg1 = 0 ;
12924 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12925 int arg3 = (int) -1 ;
12926 wxImage *result = 0 ;
12927 wxPyInputStream *temp1 ;
12928 bool created1 ;
12929 long val2 ;
12930 int ecode2 = 0 ;
12931 int val3 ;
12932 int ecode3 = 0 ;
12933 PyObject * obj0 = 0 ;
12934 PyObject * obj1 = 0 ;
12935 PyObject * obj2 = 0 ;
12936 char * kwnames[] = {
12937 (char *) "stream",(char *) "type",(char *) "index", NULL
12938 };
12939
12940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12941 {
12942 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12943 arg1 = temp1->m_wxis;
12944 created1 = false;
12945 } else {
12946 PyErr_Clear(); // clear the failure of the wxPyConvert above
12947 arg1 = wxPyCBInputStream_create(obj0, false);
12948 if (arg1 == NULL) {
12949 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12950 SWIG_fail;
12951 }
12952 created1 = true;
12953 }
12954 }
12955 if (obj1) {
12956 ecode2 = SWIG_AsVal_long(obj1, &val2);
12957 if (!SWIG_IsOK(ecode2)) {
12958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
12959 }
12960 arg2 = static_cast< long >(val2);
12961 }
12962 if (obj2) {
12963 ecode3 = SWIG_AsVal_int(obj2, &val3);
12964 if (!SWIG_IsOK(ecode3)) {
12965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
12966 }
12967 arg3 = static_cast< int >(val3);
12968 }
12969 {
12970 PyThreadState* __tstate = wxPyBeginAllowThreads();
12971 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
12972 wxPyEndAllowThreads(__tstate);
12973 if (PyErr_Occurred()) SWIG_fail;
12974 }
12975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12976 {
12977 if (created1) delete arg1;
12978 }
12979 return resultobj;
12980 fail:
12981 {
12982 if (created1) delete arg1;
12983 }
12984 return NULL;
12985 }
12986
12987
12988 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12989 PyObject *resultobj = 0;
12990 wxInputStream *arg1 = 0 ;
12991 wxString *arg2 = 0 ;
12992 int arg3 = (int) -1 ;
12993 wxImage *result = 0 ;
12994 wxPyInputStream *temp1 ;
12995 bool created1 ;
12996 bool temp2 = false ;
12997 int val3 ;
12998 int ecode3 = 0 ;
12999 PyObject * obj0 = 0 ;
13000 PyObject * obj1 = 0 ;
13001 PyObject * obj2 = 0 ;
13002 char * kwnames[] = {
13003 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13004 };
13005
13006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13007 {
13008 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13009 arg1 = temp1->m_wxis;
13010 created1 = false;
13011 } else {
13012 PyErr_Clear(); // clear the failure of the wxPyConvert above
13013 arg1 = wxPyCBInputStream_create(obj0, false);
13014 if (arg1 == NULL) {
13015 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13016 SWIG_fail;
13017 }
13018 created1 = true;
13019 }
13020 }
13021 {
13022 arg2 = wxString_in_helper(obj1);
13023 if (arg2 == NULL) SWIG_fail;
13024 temp2 = true;
13025 }
13026 if (obj2) {
13027 ecode3 = SWIG_AsVal_int(obj2, &val3);
13028 if (!SWIG_IsOK(ecode3)) {
13029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13030 }
13031 arg3 = static_cast< int >(val3);
13032 }
13033 {
13034 PyThreadState* __tstate = wxPyBeginAllowThreads();
13035 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13036 wxPyEndAllowThreads(__tstate);
13037 if (PyErr_Occurred()) SWIG_fail;
13038 }
13039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13040 {
13041 if (created1) delete arg1;
13042 }
13043 {
13044 if (temp2)
13045 delete arg2;
13046 }
13047 return resultobj;
13048 fail:
13049 {
13050 if (created1) delete arg1;
13051 }
13052 {
13053 if (temp2)
13054 delete arg2;
13055 }
13056 return NULL;
13057 }
13058
13059
13060 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13061 PyObject *resultobj = 0;
13062 int arg1 = (int) 0 ;
13063 int arg2 = (int) 0 ;
13064 bool arg3 = (bool) true ;
13065 wxImage *result = 0 ;
13066 int val1 ;
13067 int ecode1 = 0 ;
13068 int val2 ;
13069 int ecode2 = 0 ;
13070 bool val3 ;
13071 int ecode3 = 0 ;
13072 PyObject * obj0 = 0 ;
13073 PyObject * obj1 = 0 ;
13074 PyObject * obj2 = 0 ;
13075 char * kwnames[] = {
13076 (char *) "width",(char *) "height",(char *) "clear", NULL
13077 };
13078
13079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13080 if (obj0) {
13081 ecode1 = SWIG_AsVal_int(obj0, &val1);
13082 if (!SWIG_IsOK(ecode1)) {
13083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13084 }
13085 arg1 = static_cast< int >(val1);
13086 }
13087 if (obj1) {
13088 ecode2 = SWIG_AsVal_int(obj1, &val2);
13089 if (!SWIG_IsOK(ecode2)) {
13090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13091 }
13092 arg2 = static_cast< int >(val2);
13093 }
13094 if (obj2) {
13095 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13096 if (!SWIG_IsOK(ecode3)) {
13097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13098 }
13099 arg3 = static_cast< bool >(val3);
13100 }
13101 {
13102 PyThreadState* __tstate = wxPyBeginAllowThreads();
13103 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13104 wxPyEndAllowThreads(__tstate);
13105 if (PyErr_Occurred()) SWIG_fail;
13106 }
13107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13108 return resultobj;
13109 fail:
13110 return NULL;
13111 }
13112
13113
13114 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13115 PyObject *resultobj = 0;
13116 wxBitmap *arg1 = 0 ;
13117 wxImage *result = 0 ;
13118 void *argp1 = 0 ;
13119 int res1 = 0 ;
13120 PyObject * obj0 = 0 ;
13121 char * kwnames[] = {
13122 (char *) "bitmap", NULL
13123 };
13124
13125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13126 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13127 if (!SWIG_IsOK(res1)) {
13128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13129 }
13130 if (!argp1) {
13131 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13132 }
13133 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13134 {
13135 if (!wxPyCheckForApp()) SWIG_fail;
13136 PyThreadState* __tstate = wxPyBeginAllowThreads();
13137 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13138 wxPyEndAllowThreads(__tstate);
13139 if (PyErr_Occurred()) SWIG_fail;
13140 }
13141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13142 return resultobj;
13143 fail:
13144 return NULL;
13145 }
13146
13147
13148 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13149 PyObject *resultobj = 0;
13150 int arg1 ;
13151 int arg2 ;
13152 buffer arg3 ;
13153 int arg4 ;
13154 wxImage *result = 0 ;
13155 int val1 ;
13156 int ecode1 = 0 ;
13157 int val2 ;
13158 int ecode2 = 0 ;
13159 PyObject * obj0 = 0 ;
13160 PyObject * obj1 = 0 ;
13161 PyObject * obj2 = 0 ;
13162 char * kwnames[] = {
13163 (char *) "width",(char *) "height",(char *) "data", NULL
13164 };
13165
13166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13167 ecode1 = SWIG_AsVal_int(obj0, &val1);
13168 if (!SWIG_IsOK(ecode1)) {
13169 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13170 }
13171 arg1 = static_cast< int >(val1);
13172 ecode2 = SWIG_AsVal_int(obj1, &val2);
13173 if (!SWIG_IsOK(ecode2)) {
13174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13175 }
13176 arg2 = static_cast< int >(val2);
13177 {
13178 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13179 }
13180 {
13181 PyThreadState* __tstate = wxPyBeginAllowThreads();
13182 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13183 wxPyEndAllowThreads(__tstate);
13184 if (PyErr_Occurred()) SWIG_fail;
13185 }
13186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13187 return resultobj;
13188 fail:
13189 return NULL;
13190 }
13191
13192
13193 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13194 PyObject *resultobj = 0;
13195 int arg1 ;
13196 int arg2 ;
13197 buffer arg3 ;
13198 int arg4 ;
13199 buffer arg5 ;
13200 int arg6 ;
13201 wxImage *result = 0 ;
13202 int val1 ;
13203 int ecode1 = 0 ;
13204 int val2 ;
13205 int ecode2 = 0 ;
13206 PyObject * obj0 = 0 ;
13207 PyObject * obj1 = 0 ;
13208 PyObject * obj2 = 0 ;
13209 PyObject * obj3 = 0 ;
13210 char * kwnames[] = {
13211 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13212 };
13213
13214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13215 ecode1 = SWIG_AsVal_int(obj0, &val1);
13216 if (!SWIG_IsOK(ecode1)) {
13217 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13218 }
13219 arg1 = static_cast< int >(val1);
13220 ecode2 = SWIG_AsVal_int(obj1, &val2);
13221 if (!SWIG_IsOK(ecode2)) {
13222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13223 }
13224 arg2 = static_cast< int >(val2);
13225 {
13226 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13227 }
13228 {
13229 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13230 }
13231 {
13232 PyThreadState* __tstate = wxPyBeginAllowThreads();
13233 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13234 wxPyEndAllowThreads(__tstate);
13235 if (PyErr_Occurred()) SWIG_fail;
13236 }
13237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13238 return resultobj;
13239 fail:
13240 return NULL;
13241 }
13242
13243
13244 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13245 PyObject *resultobj = 0;
13246 wxImage *arg1 = (wxImage *) 0 ;
13247 int arg2 ;
13248 int arg3 ;
13249 bool arg4 = (bool) true ;
13250 void *argp1 = 0 ;
13251 int res1 = 0 ;
13252 int val2 ;
13253 int ecode2 = 0 ;
13254 int val3 ;
13255 int ecode3 = 0 ;
13256 bool val4 ;
13257 int ecode4 = 0 ;
13258 PyObject * obj0 = 0 ;
13259 PyObject * obj1 = 0 ;
13260 PyObject * obj2 = 0 ;
13261 PyObject * obj3 = 0 ;
13262 char * kwnames[] = {
13263 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13264 };
13265
13266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13268 if (!SWIG_IsOK(res1)) {
13269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13270 }
13271 arg1 = reinterpret_cast< wxImage * >(argp1);
13272 ecode2 = SWIG_AsVal_int(obj1, &val2);
13273 if (!SWIG_IsOK(ecode2)) {
13274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13275 }
13276 arg2 = static_cast< int >(val2);
13277 ecode3 = SWIG_AsVal_int(obj2, &val3);
13278 if (!SWIG_IsOK(ecode3)) {
13279 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13280 }
13281 arg3 = static_cast< int >(val3);
13282 if (obj3) {
13283 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13284 if (!SWIG_IsOK(ecode4)) {
13285 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13286 }
13287 arg4 = static_cast< bool >(val4);
13288 }
13289 {
13290 PyThreadState* __tstate = wxPyBeginAllowThreads();
13291 (arg1)->Create(arg2,arg3,arg4);
13292 wxPyEndAllowThreads(__tstate);
13293 if (PyErr_Occurred()) SWIG_fail;
13294 }
13295 resultobj = SWIG_Py_Void();
13296 return resultobj;
13297 fail:
13298 return NULL;
13299 }
13300
13301
13302 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13303 PyObject *resultobj = 0;
13304 wxImage *arg1 = (wxImage *) 0 ;
13305 void *argp1 = 0 ;
13306 int res1 = 0 ;
13307 PyObject *swig_obj[1] ;
13308
13309 if (!args) SWIG_fail;
13310 swig_obj[0] = args;
13311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13312 if (!SWIG_IsOK(res1)) {
13313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13314 }
13315 arg1 = reinterpret_cast< wxImage * >(argp1);
13316 {
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 (arg1)->Destroy();
13319 wxPyEndAllowThreads(__tstate);
13320 if (PyErr_Occurred()) SWIG_fail;
13321 }
13322 resultobj = SWIG_Py_Void();
13323 return resultobj;
13324 fail:
13325 return NULL;
13326 }
13327
13328
13329 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13330 PyObject *resultobj = 0;
13331 wxImage *arg1 = (wxImage *) 0 ;
13332 int arg2 ;
13333 int arg3 ;
13334 SwigValueWrapper<wxImage > result;
13335 void *argp1 = 0 ;
13336 int res1 = 0 ;
13337 int val2 ;
13338 int ecode2 = 0 ;
13339 int val3 ;
13340 int ecode3 = 0 ;
13341 PyObject * obj0 = 0 ;
13342 PyObject * obj1 = 0 ;
13343 PyObject * obj2 = 0 ;
13344 char * kwnames[] = {
13345 (char *) "self",(char *) "width",(char *) "height", NULL
13346 };
13347
13348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13350 if (!SWIG_IsOK(res1)) {
13351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13352 }
13353 arg1 = reinterpret_cast< wxImage * >(argp1);
13354 ecode2 = SWIG_AsVal_int(obj1, &val2);
13355 if (!SWIG_IsOK(ecode2)) {
13356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13357 }
13358 arg2 = static_cast< int >(val2);
13359 ecode3 = SWIG_AsVal_int(obj2, &val3);
13360 if (!SWIG_IsOK(ecode3)) {
13361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13362 }
13363 arg3 = static_cast< int >(val3);
13364 {
13365 PyThreadState* __tstate = wxPyBeginAllowThreads();
13366 result = (arg1)->Scale(arg2,arg3);
13367 wxPyEndAllowThreads(__tstate);
13368 if (PyErr_Occurred()) SWIG_fail;
13369 }
13370 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13371 return resultobj;
13372 fail:
13373 return NULL;
13374 }
13375
13376
13377 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13378 PyObject *resultobj = 0;
13379 wxImage *arg1 = (wxImage *) 0 ;
13380 int arg2 ;
13381 int arg3 ;
13382 SwigValueWrapper<wxImage > result;
13383 void *argp1 = 0 ;
13384 int res1 = 0 ;
13385 int val2 ;
13386 int ecode2 = 0 ;
13387 int val3 ;
13388 int ecode3 = 0 ;
13389 PyObject * obj0 = 0 ;
13390 PyObject * obj1 = 0 ;
13391 PyObject * obj2 = 0 ;
13392 char * kwnames[] = {
13393 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13394 };
13395
13396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13398 if (!SWIG_IsOK(res1)) {
13399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13400 }
13401 arg1 = reinterpret_cast< wxImage * >(argp1);
13402 ecode2 = SWIG_AsVal_int(obj1, &val2);
13403 if (!SWIG_IsOK(ecode2)) {
13404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13405 }
13406 arg2 = static_cast< int >(val2);
13407 ecode3 = SWIG_AsVal_int(obj2, &val3);
13408 if (!SWIG_IsOK(ecode3)) {
13409 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13410 }
13411 arg3 = static_cast< int >(val3);
13412 {
13413 PyThreadState* __tstate = wxPyBeginAllowThreads();
13414 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13415 wxPyEndAllowThreads(__tstate);
13416 if (PyErr_Occurred()) SWIG_fail;
13417 }
13418 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13419 return resultobj;
13420 fail:
13421 return NULL;
13422 }
13423
13424
13425 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13426 PyObject *resultobj = 0;
13427 wxImage *arg1 = (wxImage *) 0 ;
13428 int arg2 ;
13429 int arg3 ;
13430 wxImage *result = 0 ;
13431 void *argp1 = 0 ;
13432 int res1 = 0 ;
13433 int val2 ;
13434 int ecode2 = 0 ;
13435 int val3 ;
13436 int ecode3 = 0 ;
13437 PyObject * obj0 = 0 ;
13438 PyObject * obj1 = 0 ;
13439 PyObject * obj2 = 0 ;
13440 char * kwnames[] = {
13441 (char *) "self",(char *) "width",(char *) "height", NULL
13442 };
13443
13444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13446 if (!SWIG_IsOK(res1)) {
13447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13448 }
13449 arg1 = reinterpret_cast< wxImage * >(argp1);
13450 ecode2 = SWIG_AsVal_int(obj1, &val2);
13451 if (!SWIG_IsOK(ecode2)) {
13452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13453 }
13454 arg2 = static_cast< int >(val2);
13455 ecode3 = SWIG_AsVal_int(obj2, &val3);
13456 if (!SWIG_IsOK(ecode3)) {
13457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13458 }
13459 arg3 = static_cast< int >(val3);
13460 {
13461 PyThreadState* __tstate = wxPyBeginAllowThreads();
13462 {
13463 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13464 result = (wxImage *) &_result_ref;
13465 }
13466 wxPyEndAllowThreads(__tstate);
13467 if (PyErr_Occurred()) SWIG_fail;
13468 }
13469 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13470 return resultobj;
13471 fail:
13472 return NULL;
13473 }
13474
13475
13476 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13477 PyObject *resultobj = 0;
13478 wxImage *arg1 = (wxImage *) 0 ;
13479 wxSize *arg2 = 0 ;
13480 wxPoint *arg3 = 0 ;
13481 int arg4 = (int) -1 ;
13482 int arg5 = (int) -1 ;
13483 int arg6 = (int) -1 ;
13484 wxImage *result = 0 ;
13485 void *argp1 = 0 ;
13486 int res1 = 0 ;
13487 wxSize temp2 ;
13488 wxPoint temp3 ;
13489 int val4 ;
13490 int ecode4 = 0 ;
13491 int val5 ;
13492 int ecode5 = 0 ;
13493 int val6 ;
13494 int ecode6 = 0 ;
13495 PyObject * obj0 = 0 ;
13496 PyObject * obj1 = 0 ;
13497 PyObject * obj2 = 0 ;
13498 PyObject * obj3 = 0 ;
13499 PyObject * obj4 = 0 ;
13500 PyObject * obj5 = 0 ;
13501 char * kwnames[] = {
13502 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13503 };
13504
13505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13507 if (!SWIG_IsOK(res1)) {
13508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13509 }
13510 arg1 = reinterpret_cast< wxImage * >(argp1);
13511 {
13512 arg2 = &temp2;
13513 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13514 }
13515 {
13516 arg3 = &temp3;
13517 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13518 }
13519 if (obj3) {
13520 ecode4 = SWIG_AsVal_int(obj3, &val4);
13521 if (!SWIG_IsOK(ecode4)) {
13522 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13523 }
13524 arg4 = static_cast< int >(val4);
13525 }
13526 if (obj4) {
13527 ecode5 = SWIG_AsVal_int(obj4, &val5);
13528 if (!SWIG_IsOK(ecode5)) {
13529 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13530 }
13531 arg5 = static_cast< int >(val5);
13532 }
13533 if (obj5) {
13534 ecode6 = SWIG_AsVal_int(obj5, &val6);
13535 if (!SWIG_IsOK(ecode6)) {
13536 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13537 }
13538 arg6 = static_cast< int >(val6);
13539 }
13540 {
13541 PyThreadState* __tstate = wxPyBeginAllowThreads();
13542 {
13543 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13544 result = (wxImage *) &_result_ref;
13545 }
13546 wxPyEndAllowThreads(__tstate);
13547 if (PyErr_Occurred()) SWIG_fail;
13548 }
13549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13550 return resultobj;
13551 fail:
13552 return NULL;
13553 }
13554
13555
13556 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13557 PyObject *resultobj = 0;
13558 wxImage *arg1 = (wxImage *) 0 ;
13559 int arg2 ;
13560 int arg3 ;
13561 byte arg4 ;
13562 byte arg5 ;
13563 byte arg6 ;
13564 void *argp1 = 0 ;
13565 int res1 = 0 ;
13566 int val2 ;
13567 int ecode2 = 0 ;
13568 int val3 ;
13569 int ecode3 = 0 ;
13570 unsigned char val4 ;
13571 int ecode4 = 0 ;
13572 unsigned char val5 ;
13573 int ecode5 = 0 ;
13574 unsigned char val6 ;
13575 int ecode6 = 0 ;
13576 PyObject * obj0 = 0 ;
13577 PyObject * obj1 = 0 ;
13578 PyObject * obj2 = 0 ;
13579 PyObject * obj3 = 0 ;
13580 PyObject * obj4 = 0 ;
13581 PyObject * obj5 = 0 ;
13582 char * kwnames[] = {
13583 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13584 };
13585
13586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13588 if (!SWIG_IsOK(res1)) {
13589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13590 }
13591 arg1 = reinterpret_cast< wxImage * >(argp1);
13592 ecode2 = SWIG_AsVal_int(obj1, &val2);
13593 if (!SWIG_IsOK(ecode2)) {
13594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13595 }
13596 arg2 = static_cast< int >(val2);
13597 ecode3 = SWIG_AsVal_int(obj2, &val3);
13598 if (!SWIG_IsOK(ecode3)) {
13599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13600 }
13601 arg3 = static_cast< int >(val3);
13602 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13603 if (!SWIG_IsOK(ecode4)) {
13604 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13605 }
13606 arg4 = static_cast< byte >(val4);
13607 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13608 if (!SWIG_IsOK(ecode5)) {
13609 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13610 }
13611 arg5 = static_cast< byte >(val5);
13612 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13613 if (!SWIG_IsOK(ecode6)) {
13614 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13615 }
13616 arg6 = static_cast< byte >(val6);
13617 {
13618 PyThreadState* __tstate = wxPyBeginAllowThreads();
13619 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13620 wxPyEndAllowThreads(__tstate);
13621 if (PyErr_Occurred()) SWIG_fail;
13622 }
13623 resultobj = SWIG_Py_Void();
13624 return resultobj;
13625 fail:
13626 return NULL;
13627 }
13628
13629
13630 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13631 PyObject *resultobj = 0;
13632 wxImage *arg1 = (wxImage *) 0 ;
13633 wxRect *arg2 = 0 ;
13634 byte arg3 ;
13635 byte arg4 ;
13636 byte arg5 ;
13637 void *argp1 = 0 ;
13638 int res1 = 0 ;
13639 wxRect temp2 ;
13640 unsigned char val3 ;
13641 int ecode3 = 0 ;
13642 unsigned char val4 ;
13643 int ecode4 = 0 ;
13644 unsigned char val5 ;
13645 int ecode5 = 0 ;
13646 PyObject * obj0 = 0 ;
13647 PyObject * obj1 = 0 ;
13648 PyObject * obj2 = 0 ;
13649 PyObject * obj3 = 0 ;
13650 PyObject * obj4 = 0 ;
13651 char * kwnames[] = {
13652 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13653 };
13654
13655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13657 if (!SWIG_IsOK(res1)) {
13658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13659 }
13660 arg1 = reinterpret_cast< wxImage * >(argp1);
13661 {
13662 arg2 = &temp2;
13663 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13664 }
13665 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13666 if (!SWIG_IsOK(ecode3)) {
13667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13668 }
13669 arg3 = static_cast< byte >(val3);
13670 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13671 if (!SWIG_IsOK(ecode4)) {
13672 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13673 }
13674 arg4 = static_cast< byte >(val4);
13675 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13676 if (!SWIG_IsOK(ecode5)) {
13677 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13678 }
13679 arg5 = static_cast< byte >(val5);
13680 {
13681 PyThreadState* __tstate = wxPyBeginAllowThreads();
13682 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13683 wxPyEndAllowThreads(__tstate);
13684 if (PyErr_Occurred()) SWIG_fail;
13685 }
13686 resultobj = SWIG_Py_Void();
13687 return resultobj;
13688 fail:
13689 return NULL;
13690 }
13691
13692
13693 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13694 PyObject *resultobj = 0;
13695 wxImage *arg1 = (wxImage *) 0 ;
13696 int arg2 ;
13697 int arg3 ;
13698 byte result;
13699 void *argp1 = 0 ;
13700 int res1 = 0 ;
13701 int val2 ;
13702 int ecode2 = 0 ;
13703 int val3 ;
13704 int ecode3 = 0 ;
13705 PyObject * obj0 = 0 ;
13706 PyObject * obj1 = 0 ;
13707 PyObject * obj2 = 0 ;
13708 char * kwnames[] = {
13709 (char *) "self",(char *) "x",(char *) "y", NULL
13710 };
13711
13712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13714 if (!SWIG_IsOK(res1)) {
13715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13716 }
13717 arg1 = reinterpret_cast< wxImage * >(argp1);
13718 ecode2 = SWIG_AsVal_int(obj1, &val2);
13719 if (!SWIG_IsOK(ecode2)) {
13720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13721 }
13722 arg2 = static_cast< int >(val2);
13723 ecode3 = SWIG_AsVal_int(obj2, &val3);
13724 if (!SWIG_IsOK(ecode3)) {
13725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13726 }
13727 arg3 = static_cast< int >(val3);
13728 {
13729 PyThreadState* __tstate = wxPyBeginAllowThreads();
13730 result = (byte)(arg1)->GetRed(arg2,arg3);
13731 wxPyEndAllowThreads(__tstate);
13732 if (PyErr_Occurred()) SWIG_fail;
13733 }
13734 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13735 return resultobj;
13736 fail:
13737 return NULL;
13738 }
13739
13740
13741 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13742 PyObject *resultobj = 0;
13743 wxImage *arg1 = (wxImage *) 0 ;
13744 int arg2 ;
13745 int arg3 ;
13746 byte result;
13747 void *argp1 = 0 ;
13748 int res1 = 0 ;
13749 int val2 ;
13750 int ecode2 = 0 ;
13751 int val3 ;
13752 int ecode3 = 0 ;
13753 PyObject * obj0 = 0 ;
13754 PyObject * obj1 = 0 ;
13755 PyObject * obj2 = 0 ;
13756 char * kwnames[] = {
13757 (char *) "self",(char *) "x",(char *) "y", NULL
13758 };
13759
13760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13762 if (!SWIG_IsOK(res1)) {
13763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13764 }
13765 arg1 = reinterpret_cast< wxImage * >(argp1);
13766 ecode2 = SWIG_AsVal_int(obj1, &val2);
13767 if (!SWIG_IsOK(ecode2)) {
13768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13769 }
13770 arg2 = static_cast< int >(val2);
13771 ecode3 = SWIG_AsVal_int(obj2, &val3);
13772 if (!SWIG_IsOK(ecode3)) {
13773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13774 }
13775 arg3 = static_cast< int >(val3);
13776 {
13777 PyThreadState* __tstate = wxPyBeginAllowThreads();
13778 result = (byte)(arg1)->GetGreen(arg2,arg3);
13779 wxPyEndAllowThreads(__tstate);
13780 if (PyErr_Occurred()) SWIG_fail;
13781 }
13782 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13783 return resultobj;
13784 fail:
13785 return NULL;
13786 }
13787
13788
13789 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13790 PyObject *resultobj = 0;
13791 wxImage *arg1 = (wxImage *) 0 ;
13792 int arg2 ;
13793 int arg3 ;
13794 byte result;
13795 void *argp1 = 0 ;
13796 int res1 = 0 ;
13797 int val2 ;
13798 int ecode2 = 0 ;
13799 int val3 ;
13800 int ecode3 = 0 ;
13801 PyObject * obj0 = 0 ;
13802 PyObject * obj1 = 0 ;
13803 PyObject * obj2 = 0 ;
13804 char * kwnames[] = {
13805 (char *) "self",(char *) "x",(char *) "y", NULL
13806 };
13807
13808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13810 if (!SWIG_IsOK(res1)) {
13811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13812 }
13813 arg1 = reinterpret_cast< wxImage * >(argp1);
13814 ecode2 = SWIG_AsVal_int(obj1, &val2);
13815 if (!SWIG_IsOK(ecode2)) {
13816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13817 }
13818 arg2 = static_cast< int >(val2);
13819 ecode3 = SWIG_AsVal_int(obj2, &val3);
13820 if (!SWIG_IsOK(ecode3)) {
13821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13822 }
13823 arg3 = static_cast< int >(val3);
13824 {
13825 PyThreadState* __tstate = wxPyBeginAllowThreads();
13826 result = (byte)(arg1)->GetBlue(arg2,arg3);
13827 wxPyEndAllowThreads(__tstate);
13828 if (PyErr_Occurred()) SWIG_fail;
13829 }
13830 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13831 return resultobj;
13832 fail:
13833 return NULL;
13834 }
13835
13836
13837 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13838 PyObject *resultobj = 0;
13839 wxImage *arg1 = (wxImage *) 0 ;
13840 int arg2 ;
13841 int arg3 ;
13842 byte arg4 ;
13843 void *argp1 = 0 ;
13844 int res1 = 0 ;
13845 int val2 ;
13846 int ecode2 = 0 ;
13847 int val3 ;
13848 int ecode3 = 0 ;
13849 unsigned char val4 ;
13850 int ecode4 = 0 ;
13851 PyObject * obj0 = 0 ;
13852 PyObject * obj1 = 0 ;
13853 PyObject * obj2 = 0 ;
13854 PyObject * obj3 = 0 ;
13855 char * kwnames[] = {
13856 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13857 };
13858
13859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13861 if (!SWIG_IsOK(res1)) {
13862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13863 }
13864 arg1 = reinterpret_cast< wxImage * >(argp1);
13865 ecode2 = SWIG_AsVal_int(obj1, &val2);
13866 if (!SWIG_IsOK(ecode2)) {
13867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13868 }
13869 arg2 = static_cast< int >(val2);
13870 ecode3 = SWIG_AsVal_int(obj2, &val3);
13871 if (!SWIG_IsOK(ecode3)) {
13872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13873 }
13874 arg3 = static_cast< int >(val3);
13875 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13876 if (!SWIG_IsOK(ecode4)) {
13877 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13878 }
13879 arg4 = static_cast< byte >(val4);
13880 {
13881 PyThreadState* __tstate = wxPyBeginAllowThreads();
13882 (arg1)->SetAlpha(arg2,arg3,arg4);
13883 wxPyEndAllowThreads(__tstate);
13884 if (PyErr_Occurred()) SWIG_fail;
13885 }
13886 resultobj = SWIG_Py_Void();
13887 return resultobj;
13888 fail:
13889 return NULL;
13890 }
13891
13892
13893 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13894 PyObject *resultobj = 0;
13895 wxImage *arg1 = (wxImage *) 0 ;
13896 int arg2 ;
13897 int arg3 ;
13898 byte result;
13899 void *argp1 = 0 ;
13900 int res1 = 0 ;
13901 int val2 ;
13902 int ecode2 = 0 ;
13903 int val3 ;
13904 int ecode3 = 0 ;
13905 PyObject * obj0 = 0 ;
13906 PyObject * obj1 = 0 ;
13907 PyObject * obj2 = 0 ;
13908 char * kwnames[] = {
13909 (char *) "self",(char *) "x",(char *) "y", NULL
13910 };
13911
13912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13914 if (!SWIG_IsOK(res1)) {
13915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13916 }
13917 arg1 = reinterpret_cast< wxImage * >(argp1);
13918 ecode2 = SWIG_AsVal_int(obj1, &val2);
13919 if (!SWIG_IsOK(ecode2)) {
13920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13921 }
13922 arg2 = static_cast< int >(val2);
13923 ecode3 = SWIG_AsVal_int(obj2, &val3);
13924 if (!SWIG_IsOK(ecode3)) {
13925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13926 }
13927 arg3 = static_cast< int >(val3);
13928 {
13929 PyThreadState* __tstate = wxPyBeginAllowThreads();
13930 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13931 wxPyEndAllowThreads(__tstate);
13932 if (PyErr_Occurred()) SWIG_fail;
13933 }
13934 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13935 return resultobj;
13936 fail:
13937 return NULL;
13938 }
13939
13940
13941 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13942 PyObject *resultobj = 0;
13943 wxImage *arg1 = (wxImage *) 0 ;
13944 bool result;
13945 void *argp1 = 0 ;
13946 int res1 = 0 ;
13947 PyObject *swig_obj[1] ;
13948
13949 if (!args) SWIG_fail;
13950 swig_obj[0] = args;
13951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13952 if (!SWIG_IsOK(res1)) {
13953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13954 }
13955 arg1 = reinterpret_cast< wxImage * >(argp1);
13956 {
13957 PyThreadState* __tstate = wxPyBeginAllowThreads();
13958 result = (bool)(arg1)->HasAlpha();
13959 wxPyEndAllowThreads(__tstate);
13960 if (PyErr_Occurred()) SWIG_fail;
13961 }
13962 {
13963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13964 }
13965 return resultobj;
13966 fail:
13967 return NULL;
13968 }
13969
13970
13971 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13972 PyObject *resultobj = 0;
13973 wxImage *arg1 = (wxImage *) 0 ;
13974 void *argp1 = 0 ;
13975 int res1 = 0 ;
13976 PyObject *swig_obj[1] ;
13977
13978 if (!args) SWIG_fail;
13979 swig_obj[0] = args;
13980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13981 if (!SWIG_IsOK(res1)) {
13982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13983 }
13984 arg1 = reinterpret_cast< wxImage * >(argp1);
13985 {
13986 PyThreadState* __tstate = wxPyBeginAllowThreads();
13987 (arg1)->InitAlpha();
13988 wxPyEndAllowThreads(__tstate);
13989 if (PyErr_Occurred()) SWIG_fail;
13990 }
13991 resultobj = SWIG_Py_Void();
13992 return resultobj;
13993 fail:
13994 return NULL;
13995 }
13996
13997
13998 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13999 PyObject *resultobj = 0;
14000 wxImage *arg1 = (wxImage *) 0 ;
14001 int arg2 ;
14002 int arg3 ;
14003 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14004 bool result;
14005 void *argp1 = 0 ;
14006 int res1 = 0 ;
14007 int val2 ;
14008 int ecode2 = 0 ;
14009 int val3 ;
14010 int ecode3 = 0 ;
14011 unsigned char val4 ;
14012 int ecode4 = 0 ;
14013 PyObject * obj0 = 0 ;
14014 PyObject * obj1 = 0 ;
14015 PyObject * obj2 = 0 ;
14016 PyObject * obj3 = 0 ;
14017 char * kwnames[] = {
14018 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14019 };
14020
14021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14023 if (!SWIG_IsOK(res1)) {
14024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14025 }
14026 arg1 = reinterpret_cast< wxImage * >(argp1);
14027 ecode2 = SWIG_AsVal_int(obj1, &val2);
14028 if (!SWIG_IsOK(ecode2)) {
14029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14030 }
14031 arg2 = static_cast< int >(val2);
14032 ecode3 = SWIG_AsVal_int(obj2, &val3);
14033 if (!SWIG_IsOK(ecode3)) {
14034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14035 }
14036 arg3 = static_cast< int >(val3);
14037 if (obj3) {
14038 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14039 if (!SWIG_IsOK(ecode4)) {
14040 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14041 }
14042 arg4 = static_cast< byte >(val4);
14043 }
14044 {
14045 PyThreadState* __tstate = wxPyBeginAllowThreads();
14046 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14047 wxPyEndAllowThreads(__tstate);
14048 if (PyErr_Occurred()) SWIG_fail;
14049 }
14050 {
14051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14052 }
14053 return resultobj;
14054 fail:
14055 return NULL;
14056 }
14057
14058
14059 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14060 PyObject *resultobj = 0;
14061 wxImage *arg1 = (wxImage *) 0 ;
14062 byte *arg2 = (byte *) 0 ;
14063 byte *arg3 = (byte *) 0 ;
14064 byte *arg4 = (byte *) 0 ;
14065 byte arg5 = (byte) 0 ;
14066 byte arg6 = (byte) 0 ;
14067 byte arg7 = (byte) 0 ;
14068 bool result;
14069 void *argp1 = 0 ;
14070 int res1 = 0 ;
14071 byte temp2 ;
14072 int res2 = SWIG_TMPOBJ ;
14073 byte temp3 ;
14074 int res3 = SWIG_TMPOBJ ;
14075 byte temp4 ;
14076 int res4 = SWIG_TMPOBJ ;
14077 unsigned char val5 ;
14078 int ecode5 = 0 ;
14079 unsigned char val6 ;
14080 int ecode6 = 0 ;
14081 unsigned char val7 ;
14082 int ecode7 = 0 ;
14083 PyObject * obj0 = 0 ;
14084 PyObject * obj1 = 0 ;
14085 PyObject * obj2 = 0 ;
14086 PyObject * obj3 = 0 ;
14087 char * kwnames[] = {
14088 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14089 };
14090
14091 arg2 = &temp2;
14092 arg3 = &temp3;
14093 arg4 = &temp4;
14094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14096 if (!SWIG_IsOK(res1)) {
14097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14098 }
14099 arg1 = reinterpret_cast< wxImage * >(argp1);
14100 if (obj1) {
14101 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14102 if (!SWIG_IsOK(ecode5)) {
14103 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14104 }
14105 arg5 = static_cast< byte >(val5);
14106 }
14107 if (obj2) {
14108 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14109 if (!SWIG_IsOK(ecode6)) {
14110 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14111 }
14112 arg6 = static_cast< byte >(val6);
14113 }
14114 if (obj3) {
14115 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14116 if (!SWIG_IsOK(ecode7)) {
14117 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14118 }
14119 arg7 = static_cast< byte >(val7);
14120 }
14121 {
14122 PyThreadState* __tstate = wxPyBeginAllowThreads();
14123 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14124 wxPyEndAllowThreads(__tstate);
14125 if (PyErr_Occurred()) SWIG_fail;
14126 }
14127 {
14128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14129 }
14130 if (SWIG_IsTmpObj(res2)) {
14131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14132 } else {
14133 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14135 }
14136 if (SWIG_IsTmpObj(res3)) {
14137 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14138 } else {
14139 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14140 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14141 }
14142 if (SWIG_IsTmpObj(res4)) {
14143 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14144 } else {
14145 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14147 }
14148 return resultobj;
14149 fail:
14150 return NULL;
14151 }
14152
14153
14154 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14155 PyObject *resultobj = 0;
14156 wxImage *arg1 = (wxImage *) 0 ;
14157 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14158 bool result;
14159 void *argp1 = 0 ;
14160 int res1 = 0 ;
14161 unsigned char val2 ;
14162 int ecode2 = 0 ;
14163 PyObject * obj0 = 0 ;
14164 PyObject * obj1 = 0 ;
14165 char * kwnames[] = {
14166 (char *) "self",(char *) "threshold", NULL
14167 };
14168
14169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14171 if (!SWIG_IsOK(res1)) {
14172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14173 }
14174 arg1 = reinterpret_cast< wxImage * >(argp1);
14175 if (obj1) {
14176 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14177 if (!SWIG_IsOK(ecode2)) {
14178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14179 }
14180 arg2 = static_cast< byte >(val2);
14181 }
14182 {
14183 PyThreadState* __tstate = wxPyBeginAllowThreads();
14184 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14185 wxPyEndAllowThreads(__tstate);
14186 if (PyErr_Occurred()) SWIG_fail;
14187 }
14188 {
14189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14190 }
14191 return resultobj;
14192 fail:
14193 return NULL;
14194 }
14195
14196
14197 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14198 PyObject *resultobj = 0;
14199 wxImage *arg1 = (wxImage *) 0 ;
14200 byte arg2 ;
14201 byte arg3 ;
14202 byte arg4 ;
14203 bool result;
14204 void *argp1 = 0 ;
14205 int res1 = 0 ;
14206 unsigned char val2 ;
14207 int ecode2 = 0 ;
14208 unsigned char val3 ;
14209 int ecode3 = 0 ;
14210 unsigned char val4 ;
14211 int ecode4 = 0 ;
14212 PyObject * obj0 = 0 ;
14213 PyObject * obj1 = 0 ;
14214 PyObject * obj2 = 0 ;
14215 PyObject * obj3 = 0 ;
14216 char * kwnames[] = {
14217 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14218 };
14219
14220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14222 if (!SWIG_IsOK(res1)) {
14223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14224 }
14225 arg1 = reinterpret_cast< wxImage * >(argp1);
14226 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14227 if (!SWIG_IsOK(ecode2)) {
14228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14229 }
14230 arg2 = static_cast< byte >(val2);
14231 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14232 if (!SWIG_IsOK(ecode3)) {
14233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14234 }
14235 arg3 = static_cast< byte >(val3);
14236 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14237 if (!SWIG_IsOK(ecode4)) {
14238 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14239 }
14240 arg4 = static_cast< byte >(val4);
14241 {
14242 PyThreadState* __tstate = wxPyBeginAllowThreads();
14243 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14244 wxPyEndAllowThreads(__tstate);
14245 if (PyErr_Occurred()) SWIG_fail;
14246 }
14247 {
14248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14249 }
14250 return resultobj;
14251 fail:
14252 return NULL;
14253 }
14254
14255
14256 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14257 PyObject *resultobj = 0;
14258 wxImage *arg1 = (wxImage *) 0 ;
14259 wxImage *arg2 = 0 ;
14260 byte arg3 ;
14261 byte arg4 ;
14262 byte arg5 ;
14263 bool result;
14264 void *argp1 = 0 ;
14265 int res1 = 0 ;
14266 void *argp2 = 0 ;
14267 int res2 = 0 ;
14268 unsigned char val3 ;
14269 int ecode3 = 0 ;
14270 unsigned char val4 ;
14271 int ecode4 = 0 ;
14272 unsigned char val5 ;
14273 int ecode5 = 0 ;
14274 PyObject * obj0 = 0 ;
14275 PyObject * obj1 = 0 ;
14276 PyObject * obj2 = 0 ;
14277 PyObject * obj3 = 0 ;
14278 PyObject * obj4 = 0 ;
14279 char * kwnames[] = {
14280 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14281 };
14282
14283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14285 if (!SWIG_IsOK(res1)) {
14286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14287 }
14288 arg1 = reinterpret_cast< wxImage * >(argp1);
14289 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14290 if (!SWIG_IsOK(res2)) {
14291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14292 }
14293 if (!argp2) {
14294 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14295 }
14296 arg2 = reinterpret_cast< wxImage * >(argp2);
14297 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14298 if (!SWIG_IsOK(ecode3)) {
14299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14300 }
14301 arg3 = static_cast< byte >(val3);
14302 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14303 if (!SWIG_IsOK(ecode4)) {
14304 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14305 }
14306 arg4 = static_cast< byte >(val4);
14307 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14308 if (!SWIG_IsOK(ecode5)) {
14309 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14310 }
14311 arg5 = static_cast< byte >(val5);
14312 {
14313 PyThreadState* __tstate = wxPyBeginAllowThreads();
14314 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14315 wxPyEndAllowThreads(__tstate);
14316 if (PyErr_Occurred()) SWIG_fail;
14317 }
14318 {
14319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14320 }
14321 return resultobj;
14322 fail:
14323 return NULL;
14324 }
14325
14326
14327 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14328 PyObject *resultobj = 0;
14329 wxString *arg1 = 0 ;
14330 bool result;
14331 bool temp1 = false ;
14332 PyObject * obj0 = 0 ;
14333 char * kwnames[] = {
14334 (char *) "filename", NULL
14335 };
14336
14337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14338 {
14339 arg1 = wxString_in_helper(obj0);
14340 if (arg1 == NULL) SWIG_fail;
14341 temp1 = true;
14342 }
14343 {
14344 PyThreadState* __tstate = wxPyBeginAllowThreads();
14345 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14346 wxPyEndAllowThreads(__tstate);
14347 if (PyErr_Occurred()) SWIG_fail;
14348 }
14349 {
14350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14351 }
14352 {
14353 if (temp1)
14354 delete arg1;
14355 }
14356 return resultobj;
14357 fail:
14358 {
14359 if (temp1)
14360 delete arg1;
14361 }
14362 return NULL;
14363 }
14364
14365
14366 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14367 PyObject *resultobj = 0;
14368 wxString *arg1 = 0 ;
14369 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14370 int result;
14371 bool temp1 = false ;
14372 long val2 ;
14373 int ecode2 = 0 ;
14374 PyObject * obj0 = 0 ;
14375 PyObject * obj1 = 0 ;
14376 char * kwnames[] = {
14377 (char *) "filename",(char *) "type", NULL
14378 };
14379
14380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14381 {
14382 arg1 = wxString_in_helper(obj0);
14383 if (arg1 == NULL) SWIG_fail;
14384 temp1 = true;
14385 }
14386 if (obj1) {
14387 ecode2 = SWIG_AsVal_long(obj1, &val2);
14388 if (!SWIG_IsOK(ecode2)) {
14389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14390 }
14391 arg2 = static_cast< long >(val2);
14392 }
14393 {
14394 PyThreadState* __tstate = wxPyBeginAllowThreads();
14395 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14396 wxPyEndAllowThreads(__tstate);
14397 if (PyErr_Occurred()) SWIG_fail;
14398 }
14399 resultobj = SWIG_From_int(static_cast< int >(result));
14400 {
14401 if (temp1)
14402 delete arg1;
14403 }
14404 return resultobj;
14405 fail:
14406 {
14407 if (temp1)
14408 delete arg1;
14409 }
14410 return NULL;
14411 }
14412
14413
14414 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14415 PyObject *resultobj = 0;
14416 wxImage *arg1 = (wxImage *) 0 ;
14417 wxString *arg2 = 0 ;
14418 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14419 int arg4 = (int) -1 ;
14420 bool result;
14421 void *argp1 = 0 ;
14422 int res1 = 0 ;
14423 bool temp2 = false ;
14424 long val3 ;
14425 int ecode3 = 0 ;
14426 int val4 ;
14427 int ecode4 = 0 ;
14428 PyObject * obj0 = 0 ;
14429 PyObject * obj1 = 0 ;
14430 PyObject * obj2 = 0 ;
14431 PyObject * obj3 = 0 ;
14432 char * kwnames[] = {
14433 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14434 };
14435
14436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14438 if (!SWIG_IsOK(res1)) {
14439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14440 }
14441 arg1 = reinterpret_cast< wxImage * >(argp1);
14442 {
14443 arg2 = wxString_in_helper(obj1);
14444 if (arg2 == NULL) SWIG_fail;
14445 temp2 = true;
14446 }
14447 if (obj2) {
14448 ecode3 = SWIG_AsVal_long(obj2, &val3);
14449 if (!SWIG_IsOK(ecode3)) {
14450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14451 }
14452 arg3 = static_cast< long >(val3);
14453 }
14454 if (obj3) {
14455 ecode4 = SWIG_AsVal_int(obj3, &val4);
14456 if (!SWIG_IsOK(ecode4)) {
14457 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14458 }
14459 arg4 = static_cast< int >(val4);
14460 }
14461 {
14462 PyThreadState* __tstate = wxPyBeginAllowThreads();
14463 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14464 wxPyEndAllowThreads(__tstate);
14465 if (PyErr_Occurred()) SWIG_fail;
14466 }
14467 {
14468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14469 }
14470 {
14471 if (temp2)
14472 delete arg2;
14473 }
14474 return resultobj;
14475 fail:
14476 {
14477 if (temp2)
14478 delete arg2;
14479 }
14480 return NULL;
14481 }
14482
14483
14484 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14485 PyObject *resultobj = 0;
14486 wxImage *arg1 = (wxImage *) 0 ;
14487 wxString *arg2 = 0 ;
14488 wxString *arg3 = 0 ;
14489 int arg4 = (int) -1 ;
14490 bool result;
14491 void *argp1 = 0 ;
14492 int res1 = 0 ;
14493 bool temp2 = false ;
14494 bool temp3 = false ;
14495 int val4 ;
14496 int ecode4 = 0 ;
14497 PyObject * obj0 = 0 ;
14498 PyObject * obj1 = 0 ;
14499 PyObject * obj2 = 0 ;
14500 PyObject * obj3 = 0 ;
14501 char * kwnames[] = {
14502 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14503 };
14504
14505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14507 if (!SWIG_IsOK(res1)) {
14508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14509 }
14510 arg1 = reinterpret_cast< wxImage * >(argp1);
14511 {
14512 arg2 = wxString_in_helper(obj1);
14513 if (arg2 == NULL) SWIG_fail;
14514 temp2 = true;
14515 }
14516 {
14517 arg3 = wxString_in_helper(obj2);
14518 if (arg3 == NULL) SWIG_fail;
14519 temp3 = true;
14520 }
14521 if (obj3) {
14522 ecode4 = SWIG_AsVal_int(obj3, &val4);
14523 if (!SWIG_IsOK(ecode4)) {
14524 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14525 }
14526 arg4 = static_cast< int >(val4);
14527 }
14528 {
14529 PyThreadState* __tstate = wxPyBeginAllowThreads();
14530 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14531 wxPyEndAllowThreads(__tstate);
14532 if (PyErr_Occurred()) SWIG_fail;
14533 }
14534 {
14535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14536 }
14537 {
14538 if (temp2)
14539 delete arg2;
14540 }
14541 {
14542 if (temp3)
14543 delete arg3;
14544 }
14545 return resultobj;
14546 fail:
14547 {
14548 if (temp2)
14549 delete arg2;
14550 }
14551 {
14552 if (temp3)
14553 delete arg3;
14554 }
14555 return NULL;
14556 }
14557
14558
14559 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14560 PyObject *resultobj = 0;
14561 wxImage *arg1 = (wxImage *) 0 ;
14562 wxString *arg2 = 0 ;
14563 int arg3 ;
14564 bool result;
14565 void *argp1 = 0 ;
14566 int res1 = 0 ;
14567 bool temp2 = false ;
14568 int val3 ;
14569 int ecode3 = 0 ;
14570 PyObject * obj0 = 0 ;
14571 PyObject * obj1 = 0 ;
14572 PyObject * obj2 = 0 ;
14573 char * kwnames[] = {
14574 (char *) "self",(char *) "name",(char *) "type", NULL
14575 };
14576
14577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14579 if (!SWIG_IsOK(res1)) {
14580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14581 }
14582 arg1 = reinterpret_cast< wxImage * >(argp1);
14583 {
14584 arg2 = wxString_in_helper(obj1);
14585 if (arg2 == NULL) SWIG_fail;
14586 temp2 = true;
14587 }
14588 ecode3 = SWIG_AsVal_int(obj2, &val3);
14589 if (!SWIG_IsOK(ecode3)) {
14590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14591 }
14592 arg3 = static_cast< int >(val3);
14593 {
14594 PyThreadState* __tstate = wxPyBeginAllowThreads();
14595 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14596 wxPyEndAllowThreads(__tstate);
14597 if (PyErr_Occurred()) SWIG_fail;
14598 }
14599 {
14600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14601 }
14602 {
14603 if (temp2)
14604 delete arg2;
14605 }
14606 return resultobj;
14607 fail:
14608 {
14609 if (temp2)
14610 delete arg2;
14611 }
14612 return NULL;
14613 }
14614
14615
14616 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14617 PyObject *resultobj = 0;
14618 wxImage *arg1 = (wxImage *) 0 ;
14619 wxString *arg2 = 0 ;
14620 wxString *arg3 = 0 ;
14621 bool result;
14622 void *argp1 = 0 ;
14623 int res1 = 0 ;
14624 bool temp2 = false ;
14625 bool temp3 = false ;
14626 PyObject * obj0 = 0 ;
14627 PyObject * obj1 = 0 ;
14628 PyObject * obj2 = 0 ;
14629 char * kwnames[] = {
14630 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14631 };
14632
14633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14635 if (!SWIG_IsOK(res1)) {
14636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14637 }
14638 arg1 = reinterpret_cast< wxImage * >(argp1);
14639 {
14640 arg2 = wxString_in_helper(obj1);
14641 if (arg2 == NULL) SWIG_fail;
14642 temp2 = true;
14643 }
14644 {
14645 arg3 = wxString_in_helper(obj2);
14646 if (arg3 == NULL) SWIG_fail;
14647 temp3 = true;
14648 }
14649 {
14650 PyThreadState* __tstate = wxPyBeginAllowThreads();
14651 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14652 wxPyEndAllowThreads(__tstate);
14653 if (PyErr_Occurred()) SWIG_fail;
14654 }
14655 {
14656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14657 }
14658 {
14659 if (temp2)
14660 delete arg2;
14661 }
14662 {
14663 if (temp3)
14664 delete arg3;
14665 }
14666 return resultobj;
14667 fail:
14668 {
14669 if (temp2)
14670 delete arg2;
14671 }
14672 {
14673 if (temp3)
14674 delete arg3;
14675 }
14676 return NULL;
14677 }
14678
14679
14680 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14681 PyObject *resultobj = 0;
14682 wxInputStream *arg1 = 0 ;
14683 bool result;
14684 wxPyInputStream *temp1 ;
14685 bool created1 ;
14686 PyObject * obj0 = 0 ;
14687 char * kwnames[] = {
14688 (char *) "stream", NULL
14689 };
14690
14691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14692 {
14693 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14694 arg1 = temp1->m_wxis;
14695 created1 = false;
14696 } else {
14697 PyErr_Clear(); // clear the failure of the wxPyConvert above
14698 arg1 = wxPyCBInputStream_create(obj0, false);
14699 if (arg1 == NULL) {
14700 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14701 SWIG_fail;
14702 }
14703 created1 = true;
14704 }
14705 }
14706 {
14707 PyThreadState* __tstate = wxPyBeginAllowThreads();
14708 result = (bool)wxImage::CanRead(*arg1);
14709 wxPyEndAllowThreads(__tstate);
14710 if (PyErr_Occurred()) SWIG_fail;
14711 }
14712 {
14713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14714 }
14715 {
14716 if (created1) delete arg1;
14717 }
14718 return resultobj;
14719 fail:
14720 {
14721 if (created1) delete arg1;
14722 }
14723 return NULL;
14724 }
14725
14726
14727 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14728 PyObject *resultobj = 0;
14729 wxImage *arg1 = (wxImage *) 0 ;
14730 wxInputStream *arg2 = 0 ;
14731 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14732 int arg4 = (int) -1 ;
14733 bool result;
14734 void *argp1 = 0 ;
14735 int res1 = 0 ;
14736 wxPyInputStream *temp2 ;
14737 bool created2 ;
14738 long val3 ;
14739 int ecode3 = 0 ;
14740 int val4 ;
14741 int ecode4 = 0 ;
14742 PyObject * obj0 = 0 ;
14743 PyObject * obj1 = 0 ;
14744 PyObject * obj2 = 0 ;
14745 PyObject * obj3 = 0 ;
14746 char * kwnames[] = {
14747 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14748 };
14749
14750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14752 if (!SWIG_IsOK(res1)) {
14753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14754 }
14755 arg1 = reinterpret_cast< wxImage * >(argp1);
14756 {
14757 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14758 arg2 = temp2->m_wxis;
14759 created2 = false;
14760 } else {
14761 PyErr_Clear(); // clear the failure of the wxPyConvert above
14762 arg2 = wxPyCBInputStream_create(obj1, false);
14763 if (arg2 == NULL) {
14764 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14765 SWIG_fail;
14766 }
14767 created2 = true;
14768 }
14769 }
14770 if (obj2) {
14771 ecode3 = SWIG_AsVal_long(obj2, &val3);
14772 if (!SWIG_IsOK(ecode3)) {
14773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14774 }
14775 arg3 = static_cast< long >(val3);
14776 }
14777 if (obj3) {
14778 ecode4 = SWIG_AsVal_int(obj3, &val4);
14779 if (!SWIG_IsOK(ecode4)) {
14780 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14781 }
14782 arg4 = static_cast< int >(val4);
14783 }
14784 {
14785 PyThreadState* __tstate = wxPyBeginAllowThreads();
14786 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14787 wxPyEndAllowThreads(__tstate);
14788 if (PyErr_Occurred()) SWIG_fail;
14789 }
14790 {
14791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14792 }
14793 {
14794 if (created2) delete arg2;
14795 }
14796 return resultobj;
14797 fail:
14798 {
14799 if (created2) delete arg2;
14800 }
14801 return NULL;
14802 }
14803
14804
14805 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14806 PyObject *resultobj = 0;
14807 wxImage *arg1 = (wxImage *) 0 ;
14808 wxInputStream *arg2 = 0 ;
14809 wxString *arg3 = 0 ;
14810 int arg4 = (int) -1 ;
14811 bool result;
14812 void *argp1 = 0 ;
14813 int res1 = 0 ;
14814 wxPyInputStream *temp2 ;
14815 bool created2 ;
14816 bool temp3 = false ;
14817 int val4 ;
14818 int ecode4 = 0 ;
14819 PyObject * obj0 = 0 ;
14820 PyObject * obj1 = 0 ;
14821 PyObject * obj2 = 0 ;
14822 PyObject * obj3 = 0 ;
14823 char * kwnames[] = {
14824 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14825 };
14826
14827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14829 if (!SWIG_IsOK(res1)) {
14830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14831 }
14832 arg1 = reinterpret_cast< wxImage * >(argp1);
14833 {
14834 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14835 arg2 = temp2->m_wxis;
14836 created2 = false;
14837 } else {
14838 PyErr_Clear(); // clear the failure of the wxPyConvert above
14839 arg2 = wxPyCBInputStream_create(obj1, false);
14840 if (arg2 == NULL) {
14841 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14842 SWIG_fail;
14843 }
14844 created2 = true;
14845 }
14846 }
14847 {
14848 arg3 = wxString_in_helper(obj2);
14849 if (arg3 == NULL) SWIG_fail;
14850 temp3 = true;
14851 }
14852 if (obj3) {
14853 ecode4 = SWIG_AsVal_int(obj3, &val4);
14854 if (!SWIG_IsOK(ecode4)) {
14855 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14856 }
14857 arg4 = static_cast< int >(val4);
14858 }
14859 {
14860 PyThreadState* __tstate = wxPyBeginAllowThreads();
14861 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14862 wxPyEndAllowThreads(__tstate);
14863 if (PyErr_Occurred()) SWIG_fail;
14864 }
14865 {
14866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14867 }
14868 {
14869 if (created2) delete arg2;
14870 }
14871 {
14872 if (temp3)
14873 delete arg3;
14874 }
14875 return resultobj;
14876 fail:
14877 {
14878 if (created2) delete arg2;
14879 }
14880 {
14881 if (temp3)
14882 delete arg3;
14883 }
14884 return NULL;
14885 }
14886
14887
14888 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14889 PyObject *resultobj = 0;
14890 wxImage *arg1 = (wxImage *) 0 ;
14891 bool result;
14892 void *argp1 = 0 ;
14893 int res1 = 0 ;
14894 PyObject *swig_obj[1] ;
14895
14896 if (!args) SWIG_fail;
14897 swig_obj[0] = args;
14898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14899 if (!SWIG_IsOK(res1)) {
14900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14901 }
14902 arg1 = reinterpret_cast< wxImage * >(argp1);
14903 {
14904 PyThreadState* __tstate = wxPyBeginAllowThreads();
14905 result = (bool)(arg1)->Ok();
14906 wxPyEndAllowThreads(__tstate);
14907 if (PyErr_Occurred()) SWIG_fail;
14908 }
14909 {
14910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14911 }
14912 return resultobj;
14913 fail:
14914 return NULL;
14915 }
14916
14917
14918 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14919 PyObject *resultobj = 0;
14920 wxImage *arg1 = (wxImage *) 0 ;
14921 int result;
14922 void *argp1 = 0 ;
14923 int res1 = 0 ;
14924 PyObject *swig_obj[1] ;
14925
14926 if (!args) SWIG_fail;
14927 swig_obj[0] = args;
14928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14929 if (!SWIG_IsOK(res1)) {
14930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14931 }
14932 arg1 = reinterpret_cast< wxImage * >(argp1);
14933 {
14934 PyThreadState* __tstate = wxPyBeginAllowThreads();
14935 result = (int)(arg1)->GetWidth();
14936 wxPyEndAllowThreads(__tstate);
14937 if (PyErr_Occurred()) SWIG_fail;
14938 }
14939 resultobj = SWIG_From_int(static_cast< int >(result));
14940 return resultobj;
14941 fail:
14942 return NULL;
14943 }
14944
14945
14946 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14947 PyObject *resultobj = 0;
14948 wxImage *arg1 = (wxImage *) 0 ;
14949 int result;
14950 void *argp1 = 0 ;
14951 int res1 = 0 ;
14952 PyObject *swig_obj[1] ;
14953
14954 if (!args) SWIG_fail;
14955 swig_obj[0] = args;
14956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14957 if (!SWIG_IsOK(res1)) {
14958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
14959 }
14960 arg1 = reinterpret_cast< wxImage * >(argp1);
14961 {
14962 PyThreadState* __tstate = wxPyBeginAllowThreads();
14963 result = (int)(arg1)->GetHeight();
14964 wxPyEndAllowThreads(__tstate);
14965 if (PyErr_Occurred()) SWIG_fail;
14966 }
14967 resultobj = SWIG_From_int(static_cast< int >(result));
14968 return resultobj;
14969 fail:
14970 return NULL;
14971 }
14972
14973
14974 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14975 PyObject *resultobj = 0;
14976 wxImage *arg1 = (wxImage *) 0 ;
14977 wxSize result;
14978 void *argp1 = 0 ;
14979 int res1 = 0 ;
14980 PyObject *swig_obj[1] ;
14981
14982 if (!args) SWIG_fail;
14983 swig_obj[0] = args;
14984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14985 if (!SWIG_IsOK(res1)) {
14986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
14987 }
14988 arg1 = reinterpret_cast< wxImage * >(argp1);
14989 {
14990 PyThreadState* __tstate = wxPyBeginAllowThreads();
14991 result = wxImage_GetSize(arg1);
14992 wxPyEndAllowThreads(__tstate);
14993 if (PyErr_Occurred()) SWIG_fail;
14994 }
14995 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
14996 return resultobj;
14997 fail:
14998 return NULL;
14999 }
15000
15001
15002 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15003 PyObject *resultobj = 0;
15004 wxImage *arg1 = (wxImage *) 0 ;
15005 wxRect *arg2 = 0 ;
15006 SwigValueWrapper<wxImage > result;
15007 void *argp1 = 0 ;
15008 int res1 = 0 ;
15009 wxRect temp2 ;
15010 PyObject * obj0 = 0 ;
15011 PyObject * obj1 = 0 ;
15012 char * kwnames[] = {
15013 (char *) "self",(char *) "rect", NULL
15014 };
15015
15016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15018 if (!SWIG_IsOK(res1)) {
15019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15020 }
15021 arg1 = reinterpret_cast< wxImage * >(argp1);
15022 {
15023 arg2 = &temp2;
15024 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15025 }
15026 {
15027 PyThreadState* __tstate = wxPyBeginAllowThreads();
15028 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15029 wxPyEndAllowThreads(__tstate);
15030 if (PyErr_Occurred()) SWIG_fail;
15031 }
15032 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15033 return resultobj;
15034 fail:
15035 return NULL;
15036 }
15037
15038
15039 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15040 PyObject *resultobj = 0;
15041 wxImage *arg1 = (wxImage *) 0 ;
15042 wxSize *arg2 = 0 ;
15043 wxPoint *arg3 = 0 ;
15044 int arg4 = (int) -1 ;
15045 int arg5 = (int) -1 ;
15046 int arg6 = (int) -1 ;
15047 SwigValueWrapper<wxImage > result;
15048 void *argp1 = 0 ;
15049 int res1 = 0 ;
15050 wxSize temp2 ;
15051 wxPoint temp3 ;
15052 int val4 ;
15053 int ecode4 = 0 ;
15054 int val5 ;
15055 int ecode5 = 0 ;
15056 int val6 ;
15057 int ecode6 = 0 ;
15058 PyObject * obj0 = 0 ;
15059 PyObject * obj1 = 0 ;
15060 PyObject * obj2 = 0 ;
15061 PyObject * obj3 = 0 ;
15062 PyObject * obj4 = 0 ;
15063 PyObject * obj5 = 0 ;
15064 char * kwnames[] = {
15065 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15066 };
15067
15068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15070 if (!SWIG_IsOK(res1)) {
15071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15072 }
15073 arg1 = reinterpret_cast< wxImage * >(argp1);
15074 {
15075 arg2 = &temp2;
15076 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15077 }
15078 {
15079 arg3 = &temp3;
15080 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15081 }
15082 if (obj3) {
15083 ecode4 = SWIG_AsVal_int(obj3, &val4);
15084 if (!SWIG_IsOK(ecode4)) {
15085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15086 }
15087 arg4 = static_cast< int >(val4);
15088 }
15089 if (obj4) {
15090 ecode5 = SWIG_AsVal_int(obj4, &val5);
15091 if (!SWIG_IsOK(ecode5)) {
15092 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15093 }
15094 arg5 = static_cast< int >(val5);
15095 }
15096 if (obj5) {
15097 ecode6 = SWIG_AsVal_int(obj5, &val6);
15098 if (!SWIG_IsOK(ecode6)) {
15099 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15100 }
15101 arg6 = static_cast< int >(val6);
15102 }
15103 {
15104 PyThreadState* __tstate = wxPyBeginAllowThreads();
15105 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15110 return resultobj;
15111 fail:
15112 return NULL;
15113 }
15114
15115
15116 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15117 PyObject *resultobj = 0;
15118 wxImage *arg1 = (wxImage *) 0 ;
15119 SwigValueWrapper<wxImage > result;
15120 void *argp1 = 0 ;
15121 int res1 = 0 ;
15122 PyObject *swig_obj[1] ;
15123
15124 if (!args) SWIG_fail;
15125 swig_obj[0] = args;
15126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15127 if (!SWIG_IsOK(res1)) {
15128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15129 }
15130 arg1 = reinterpret_cast< wxImage * >(argp1);
15131 {
15132 PyThreadState* __tstate = wxPyBeginAllowThreads();
15133 result = (arg1)->Copy();
15134 wxPyEndAllowThreads(__tstate);
15135 if (PyErr_Occurred()) SWIG_fail;
15136 }
15137 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15138 return resultobj;
15139 fail:
15140 return NULL;
15141 }
15142
15143
15144 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15145 PyObject *resultobj = 0;
15146 wxImage *arg1 = (wxImage *) 0 ;
15147 wxImage *arg2 = 0 ;
15148 int arg3 ;
15149 int arg4 ;
15150 void *argp1 = 0 ;
15151 int res1 = 0 ;
15152 void *argp2 = 0 ;
15153 int res2 = 0 ;
15154 int val3 ;
15155 int ecode3 = 0 ;
15156 int val4 ;
15157 int ecode4 = 0 ;
15158 PyObject * obj0 = 0 ;
15159 PyObject * obj1 = 0 ;
15160 PyObject * obj2 = 0 ;
15161 PyObject * obj3 = 0 ;
15162 char * kwnames[] = {
15163 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15164 };
15165
15166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15168 if (!SWIG_IsOK(res1)) {
15169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15170 }
15171 arg1 = reinterpret_cast< wxImage * >(argp1);
15172 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15173 if (!SWIG_IsOK(res2)) {
15174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15175 }
15176 if (!argp2) {
15177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15178 }
15179 arg2 = reinterpret_cast< wxImage * >(argp2);
15180 ecode3 = SWIG_AsVal_int(obj2, &val3);
15181 if (!SWIG_IsOK(ecode3)) {
15182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15183 }
15184 arg3 = static_cast< int >(val3);
15185 ecode4 = SWIG_AsVal_int(obj3, &val4);
15186 if (!SWIG_IsOK(ecode4)) {
15187 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15188 }
15189 arg4 = static_cast< int >(val4);
15190 {
15191 PyThreadState* __tstate = wxPyBeginAllowThreads();
15192 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15193 wxPyEndAllowThreads(__tstate);
15194 if (PyErr_Occurred()) SWIG_fail;
15195 }
15196 resultobj = SWIG_Py_Void();
15197 return resultobj;
15198 fail:
15199 return NULL;
15200 }
15201
15202
15203 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15204 PyObject *resultobj = 0;
15205 wxImage *arg1 = (wxImage *) 0 ;
15206 PyObject *result = 0 ;
15207 void *argp1 = 0 ;
15208 int res1 = 0 ;
15209 PyObject *swig_obj[1] ;
15210
15211 if (!args) SWIG_fail;
15212 swig_obj[0] = args;
15213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15214 if (!SWIG_IsOK(res1)) {
15215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15216 }
15217 arg1 = reinterpret_cast< wxImage * >(argp1);
15218 {
15219 PyThreadState* __tstate = wxPyBeginAllowThreads();
15220 result = (PyObject *)wxImage_GetData(arg1);
15221 wxPyEndAllowThreads(__tstate);
15222 if (PyErr_Occurred()) SWIG_fail;
15223 }
15224 resultobj = result;
15225 return resultobj;
15226 fail:
15227 return NULL;
15228 }
15229
15230
15231 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15232 PyObject *resultobj = 0;
15233 wxImage *arg1 = (wxImage *) 0 ;
15234 buffer arg2 ;
15235 int arg3 ;
15236 void *argp1 = 0 ;
15237 int res1 = 0 ;
15238 PyObject * obj0 = 0 ;
15239 PyObject * obj1 = 0 ;
15240 char * kwnames[] = {
15241 (char *) "self",(char *) "data", NULL
15242 };
15243
15244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15246 if (!SWIG_IsOK(res1)) {
15247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15248 }
15249 arg1 = reinterpret_cast< wxImage * >(argp1);
15250 {
15251 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15252 }
15253 {
15254 PyThreadState* __tstate = wxPyBeginAllowThreads();
15255 wxImage_SetData(arg1,arg2,arg3);
15256 wxPyEndAllowThreads(__tstate);
15257 if (PyErr_Occurred()) SWIG_fail;
15258 }
15259 resultobj = SWIG_Py_Void();
15260 return resultobj;
15261 fail:
15262 return NULL;
15263 }
15264
15265
15266 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15267 PyObject *resultobj = 0;
15268 wxImage *arg1 = (wxImage *) 0 ;
15269 PyObject *result = 0 ;
15270 void *argp1 = 0 ;
15271 int res1 = 0 ;
15272 PyObject *swig_obj[1] ;
15273
15274 if (!args) SWIG_fail;
15275 swig_obj[0] = args;
15276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15277 if (!SWIG_IsOK(res1)) {
15278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15279 }
15280 arg1 = reinterpret_cast< wxImage * >(argp1);
15281 {
15282 PyThreadState* __tstate = wxPyBeginAllowThreads();
15283 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15284 wxPyEndAllowThreads(__tstate);
15285 if (PyErr_Occurred()) SWIG_fail;
15286 }
15287 resultobj = result;
15288 return resultobj;
15289 fail:
15290 return NULL;
15291 }
15292
15293
15294 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15295 PyObject *resultobj = 0;
15296 wxImage *arg1 = (wxImage *) 0 ;
15297 buffer arg2 ;
15298 int arg3 ;
15299 void *argp1 = 0 ;
15300 int res1 = 0 ;
15301 PyObject * obj0 = 0 ;
15302 PyObject * obj1 = 0 ;
15303 char * kwnames[] = {
15304 (char *) "self",(char *) "data", NULL
15305 };
15306
15307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15309 if (!SWIG_IsOK(res1)) {
15310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15311 }
15312 arg1 = reinterpret_cast< wxImage * >(argp1);
15313 {
15314 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15315 }
15316 {
15317 PyThreadState* __tstate = wxPyBeginAllowThreads();
15318 wxImage_SetDataBuffer(arg1,arg2,arg3);
15319 wxPyEndAllowThreads(__tstate);
15320 if (PyErr_Occurred()) SWIG_fail;
15321 }
15322 resultobj = SWIG_Py_Void();
15323 return resultobj;
15324 fail:
15325 return NULL;
15326 }
15327
15328
15329 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15330 PyObject *resultobj = 0;
15331 wxImage *arg1 = (wxImage *) 0 ;
15332 PyObject *result = 0 ;
15333 void *argp1 = 0 ;
15334 int res1 = 0 ;
15335 PyObject *swig_obj[1] ;
15336
15337 if (!args) SWIG_fail;
15338 swig_obj[0] = args;
15339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15340 if (!SWIG_IsOK(res1)) {
15341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15342 }
15343 arg1 = reinterpret_cast< wxImage * >(argp1);
15344 {
15345 PyThreadState* __tstate = wxPyBeginAllowThreads();
15346 result = (PyObject *)wxImage_GetAlphaData(arg1);
15347 wxPyEndAllowThreads(__tstate);
15348 if (PyErr_Occurred()) SWIG_fail;
15349 }
15350 resultobj = result;
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15358 PyObject *resultobj = 0;
15359 wxImage *arg1 = (wxImage *) 0 ;
15360 buffer arg2 ;
15361 int arg3 ;
15362 void *argp1 = 0 ;
15363 int res1 = 0 ;
15364 PyObject * obj0 = 0 ;
15365 PyObject * obj1 = 0 ;
15366 char * kwnames[] = {
15367 (char *) "self",(char *) "alpha", NULL
15368 };
15369
15370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15372 if (!SWIG_IsOK(res1)) {
15373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15374 }
15375 arg1 = reinterpret_cast< wxImage * >(argp1);
15376 {
15377 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15378 }
15379 {
15380 PyThreadState* __tstate = wxPyBeginAllowThreads();
15381 wxImage_SetAlphaData(arg1,arg2,arg3);
15382 wxPyEndAllowThreads(__tstate);
15383 if (PyErr_Occurred()) SWIG_fail;
15384 }
15385 resultobj = SWIG_Py_Void();
15386 return resultobj;
15387 fail:
15388 return NULL;
15389 }
15390
15391
15392 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15393 PyObject *resultobj = 0;
15394 wxImage *arg1 = (wxImage *) 0 ;
15395 PyObject *result = 0 ;
15396 void *argp1 = 0 ;
15397 int res1 = 0 ;
15398 PyObject *swig_obj[1] ;
15399
15400 if (!args) SWIG_fail;
15401 swig_obj[0] = args;
15402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15403 if (!SWIG_IsOK(res1)) {
15404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15405 }
15406 arg1 = reinterpret_cast< wxImage * >(argp1);
15407 {
15408 PyThreadState* __tstate = wxPyBeginAllowThreads();
15409 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15410 wxPyEndAllowThreads(__tstate);
15411 if (PyErr_Occurred()) SWIG_fail;
15412 }
15413 resultobj = result;
15414 return resultobj;
15415 fail:
15416 return NULL;
15417 }
15418
15419
15420 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15421 PyObject *resultobj = 0;
15422 wxImage *arg1 = (wxImage *) 0 ;
15423 buffer arg2 ;
15424 int arg3 ;
15425 void *argp1 = 0 ;
15426 int res1 = 0 ;
15427 PyObject * obj0 = 0 ;
15428 PyObject * obj1 = 0 ;
15429 char * kwnames[] = {
15430 (char *) "self",(char *) "alpha", NULL
15431 };
15432
15433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15435 if (!SWIG_IsOK(res1)) {
15436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15437 }
15438 arg1 = reinterpret_cast< wxImage * >(argp1);
15439 {
15440 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15441 }
15442 {
15443 PyThreadState* __tstate = wxPyBeginAllowThreads();
15444 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15445 wxPyEndAllowThreads(__tstate);
15446 if (PyErr_Occurred()) SWIG_fail;
15447 }
15448 resultobj = SWIG_Py_Void();
15449 return resultobj;
15450 fail:
15451 return NULL;
15452 }
15453
15454
15455 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15456 PyObject *resultobj = 0;
15457 wxImage *arg1 = (wxImage *) 0 ;
15458 byte arg2 ;
15459 byte arg3 ;
15460 byte arg4 ;
15461 void *argp1 = 0 ;
15462 int res1 = 0 ;
15463 unsigned char val2 ;
15464 int ecode2 = 0 ;
15465 unsigned char val3 ;
15466 int ecode3 = 0 ;
15467 unsigned char val4 ;
15468 int ecode4 = 0 ;
15469 PyObject * obj0 = 0 ;
15470 PyObject * obj1 = 0 ;
15471 PyObject * obj2 = 0 ;
15472 PyObject * obj3 = 0 ;
15473 char * kwnames[] = {
15474 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15475 };
15476
15477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15479 if (!SWIG_IsOK(res1)) {
15480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15481 }
15482 arg1 = reinterpret_cast< wxImage * >(argp1);
15483 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15484 if (!SWIG_IsOK(ecode2)) {
15485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15486 }
15487 arg2 = static_cast< byte >(val2);
15488 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15489 if (!SWIG_IsOK(ecode3)) {
15490 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15491 }
15492 arg3 = static_cast< byte >(val3);
15493 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15494 if (!SWIG_IsOK(ecode4)) {
15495 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15496 }
15497 arg4 = static_cast< byte >(val4);
15498 {
15499 PyThreadState* __tstate = wxPyBeginAllowThreads();
15500 (arg1)->SetMaskColour(arg2,arg3,arg4);
15501 wxPyEndAllowThreads(__tstate);
15502 if (PyErr_Occurred()) SWIG_fail;
15503 }
15504 resultobj = SWIG_Py_Void();
15505 return resultobj;
15506 fail:
15507 return NULL;
15508 }
15509
15510
15511 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15512 PyObject *resultobj = 0;
15513 wxImage *arg1 = (wxImage *) 0 ;
15514 byte *arg2 = (byte *) 0 ;
15515 byte *arg3 = (byte *) 0 ;
15516 byte *arg4 = (byte *) 0 ;
15517 void *argp1 = 0 ;
15518 int res1 = 0 ;
15519 byte temp2 ;
15520 int res2 = SWIG_TMPOBJ ;
15521 byte temp3 ;
15522 int res3 = SWIG_TMPOBJ ;
15523 byte temp4 ;
15524 int res4 = SWIG_TMPOBJ ;
15525 PyObject *swig_obj[1] ;
15526
15527 arg2 = &temp2;
15528 arg3 = &temp3;
15529 arg4 = &temp4;
15530 if (!args) SWIG_fail;
15531 swig_obj[0] = args;
15532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15533 if (!SWIG_IsOK(res1)) {
15534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15535 }
15536 arg1 = reinterpret_cast< wxImage * >(argp1);
15537 {
15538 PyThreadState* __tstate = wxPyBeginAllowThreads();
15539 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15540 wxPyEndAllowThreads(__tstate);
15541 if (PyErr_Occurred()) SWIG_fail;
15542 }
15543 resultobj = SWIG_Py_Void();
15544 if (SWIG_IsTmpObj(res2)) {
15545 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15546 } else {
15547 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15548 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15549 }
15550 if (SWIG_IsTmpObj(res3)) {
15551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15552 } else {
15553 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15555 }
15556 if (SWIG_IsTmpObj(res4)) {
15557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15558 } else {
15559 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15561 }
15562 return resultobj;
15563 fail:
15564 return NULL;
15565 }
15566
15567
15568 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15569 PyObject *resultobj = 0;
15570 wxImage *arg1 = (wxImage *) 0 ;
15571 byte result;
15572 void *argp1 = 0 ;
15573 int res1 = 0 ;
15574 PyObject *swig_obj[1] ;
15575
15576 if (!args) SWIG_fail;
15577 swig_obj[0] = args;
15578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15579 if (!SWIG_IsOK(res1)) {
15580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15581 }
15582 arg1 = reinterpret_cast< wxImage * >(argp1);
15583 {
15584 PyThreadState* __tstate = wxPyBeginAllowThreads();
15585 result = (byte)(arg1)->GetMaskRed();
15586 wxPyEndAllowThreads(__tstate);
15587 if (PyErr_Occurred()) SWIG_fail;
15588 }
15589 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15590 return resultobj;
15591 fail:
15592 return NULL;
15593 }
15594
15595
15596 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15597 PyObject *resultobj = 0;
15598 wxImage *arg1 = (wxImage *) 0 ;
15599 byte result;
15600 void *argp1 = 0 ;
15601 int res1 = 0 ;
15602 PyObject *swig_obj[1] ;
15603
15604 if (!args) SWIG_fail;
15605 swig_obj[0] = args;
15606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15607 if (!SWIG_IsOK(res1)) {
15608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15609 }
15610 arg1 = reinterpret_cast< wxImage * >(argp1);
15611 {
15612 PyThreadState* __tstate = wxPyBeginAllowThreads();
15613 result = (byte)(arg1)->GetMaskGreen();
15614 wxPyEndAllowThreads(__tstate);
15615 if (PyErr_Occurred()) SWIG_fail;
15616 }
15617 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15618 return resultobj;
15619 fail:
15620 return NULL;
15621 }
15622
15623
15624 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15625 PyObject *resultobj = 0;
15626 wxImage *arg1 = (wxImage *) 0 ;
15627 byte result;
15628 void *argp1 = 0 ;
15629 int res1 = 0 ;
15630 PyObject *swig_obj[1] ;
15631
15632 if (!args) SWIG_fail;
15633 swig_obj[0] = args;
15634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15635 if (!SWIG_IsOK(res1)) {
15636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15637 }
15638 arg1 = reinterpret_cast< wxImage * >(argp1);
15639 {
15640 PyThreadState* __tstate = wxPyBeginAllowThreads();
15641 result = (byte)(arg1)->GetMaskBlue();
15642 wxPyEndAllowThreads(__tstate);
15643 if (PyErr_Occurred()) SWIG_fail;
15644 }
15645 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15646 return resultobj;
15647 fail:
15648 return NULL;
15649 }
15650
15651
15652 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15653 PyObject *resultobj = 0;
15654 wxImage *arg1 = (wxImage *) 0 ;
15655 bool arg2 = (bool) true ;
15656 void *argp1 = 0 ;
15657 int res1 = 0 ;
15658 bool val2 ;
15659 int ecode2 = 0 ;
15660 PyObject * obj0 = 0 ;
15661 PyObject * obj1 = 0 ;
15662 char * kwnames[] = {
15663 (char *) "self",(char *) "mask", NULL
15664 };
15665
15666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15668 if (!SWIG_IsOK(res1)) {
15669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15670 }
15671 arg1 = reinterpret_cast< wxImage * >(argp1);
15672 if (obj1) {
15673 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15674 if (!SWIG_IsOK(ecode2)) {
15675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15676 }
15677 arg2 = static_cast< bool >(val2);
15678 }
15679 {
15680 PyThreadState* __tstate = wxPyBeginAllowThreads();
15681 (arg1)->SetMask(arg2);
15682 wxPyEndAllowThreads(__tstate);
15683 if (PyErr_Occurred()) SWIG_fail;
15684 }
15685 resultobj = SWIG_Py_Void();
15686 return resultobj;
15687 fail:
15688 return NULL;
15689 }
15690
15691
15692 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15693 PyObject *resultobj = 0;
15694 wxImage *arg1 = (wxImage *) 0 ;
15695 bool result;
15696 void *argp1 = 0 ;
15697 int res1 = 0 ;
15698 PyObject *swig_obj[1] ;
15699
15700 if (!args) SWIG_fail;
15701 swig_obj[0] = args;
15702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15703 if (!SWIG_IsOK(res1)) {
15704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15705 }
15706 arg1 = reinterpret_cast< wxImage * >(argp1);
15707 {
15708 PyThreadState* __tstate = wxPyBeginAllowThreads();
15709 result = (bool)(arg1)->HasMask();
15710 wxPyEndAllowThreads(__tstate);
15711 if (PyErr_Occurred()) SWIG_fail;
15712 }
15713 {
15714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15715 }
15716 return resultobj;
15717 fail:
15718 return NULL;
15719 }
15720
15721
15722 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15723 PyObject *resultobj = 0;
15724 wxImage *arg1 = (wxImage *) 0 ;
15725 double arg2 ;
15726 wxPoint *arg3 = 0 ;
15727 bool arg4 = (bool) true ;
15728 wxPoint *arg5 = (wxPoint *) NULL ;
15729 SwigValueWrapper<wxImage > result;
15730 void *argp1 = 0 ;
15731 int res1 = 0 ;
15732 double val2 ;
15733 int ecode2 = 0 ;
15734 wxPoint temp3 ;
15735 bool val4 ;
15736 int ecode4 = 0 ;
15737 void *argp5 = 0 ;
15738 int res5 = 0 ;
15739 PyObject * obj0 = 0 ;
15740 PyObject * obj1 = 0 ;
15741 PyObject * obj2 = 0 ;
15742 PyObject * obj3 = 0 ;
15743 PyObject * obj4 = 0 ;
15744 char * kwnames[] = {
15745 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15746 };
15747
15748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15750 if (!SWIG_IsOK(res1)) {
15751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15752 }
15753 arg1 = reinterpret_cast< wxImage * >(argp1);
15754 ecode2 = SWIG_AsVal_double(obj1, &val2);
15755 if (!SWIG_IsOK(ecode2)) {
15756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15757 }
15758 arg2 = static_cast< double >(val2);
15759 {
15760 arg3 = &temp3;
15761 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15762 }
15763 if (obj3) {
15764 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15765 if (!SWIG_IsOK(ecode4)) {
15766 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15767 }
15768 arg4 = static_cast< bool >(val4);
15769 }
15770 if (obj4) {
15771 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15772 if (!SWIG_IsOK(res5)) {
15773 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15774 }
15775 arg5 = reinterpret_cast< wxPoint * >(argp5);
15776 }
15777 {
15778 PyThreadState* __tstate = wxPyBeginAllowThreads();
15779 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15780 wxPyEndAllowThreads(__tstate);
15781 if (PyErr_Occurred()) SWIG_fail;
15782 }
15783 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15784 return resultobj;
15785 fail:
15786 return NULL;
15787 }
15788
15789
15790 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15791 PyObject *resultobj = 0;
15792 wxImage *arg1 = (wxImage *) 0 ;
15793 bool arg2 = (bool) true ;
15794 SwigValueWrapper<wxImage > result;
15795 void *argp1 = 0 ;
15796 int res1 = 0 ;
15797 bool val2 ;
15798 int ecode2 = 0 ;
15799 PyObject * obj0 = 0 ;
15800 PyObject * obj1 = 0 ;
15801 char * kwnames[] = {
15802 (char *) "self",(char *) "clockwise", NULL
15803 };
15804
15805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15807 if (!SWIG_IsOK(res1)) {
15808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15809 }
15810 arg1 = reinterpret_cast< wxImage * >(argp1);
15811 if (obj1) {
15812 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15813 if (!SWIG_IsOK(ecode2)) {
15814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15815 }
15816 arg2 = static_cast< bool >(val2);
15817 }
15818 {
15819 PyThreadState* __tstate = wxPyBeginAllowThreads();
15820 result = (arg1)->Rotate90(arg2);
15821 wxPyEndAllowThreads(__tstate);
15822 if (PyErr_Occurred()) SWIG_fail;
15823 }
15824 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15825 return resultobj;
15826 fail:
15827 return NULL;
15828 }
15829
15830
15831 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15832 PyObject *resultobj = 0;
15833 wxImage *arg1 = (wxImage *) 0 ;
15834 bool arg2 = (bool) true ;
15835 SwigValueWrapper<wxImage > result;
15836 void *argp1 = 0 ;
15837 int res1 = 0 ;
15838 bool val2 ;
15839 int ecode2 = 0 ;
15840 PyObject * obj0 = 0 ;
15841 PyObject * obj1 = 0 ;
15842 char * kwnames[] = {
15843 (char *) "self",(char *) "horizontally", NULL
15844 };
15845
15846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15848 if (!SWIG_IsOK(res1)) {
15849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15850 }
15851 arg1 = reinterpret_cast< wxImage * >(argp1);
15852 if (obj1) {
15853 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15854 if (!SWIG_IsOK(ecode2)) {
15855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15856 }
15857 arg2 = static_cast< bool >(val2);
15858 }
15859 {
15860 PyThreadState* __tstate = wxPyBeginAllowThreads();
15861 result = (arg1)->Mirror(arg2);
15862 wxPyEndAllowThreads(__tstate);
15863 if (PyErr_Occurred()) SWIG_fail;
15864 }
15865 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15866 return resultobj;
15867 fail:
15868 return NULL;
15869 }
15870
15871
15872 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15873 PyObject *resultobj = 0;
15874 wxImage *arg1 = (wxImage *) 0 ;
15875 byte arg2 ;
15876 byte arg3 ;
15877 byte arg4 ;
15878 byte arg5 ;
15879 byte arg6 ;
15880 byte arg7 ;
15881 void *argp1 = 0 ;
15882 int res1 = 0 ;
15883 unsigned char val2 ;
15884 int ecode2 = 0 ;
15885 unsigned char val3 ;
15886 int ecode3 = 0 ;
15887 unsigned char val4 ;
15888 int ecode4 = 0 ;
15889 unsigned char val5 ;
15890 int ecode5 = 0 ;
15891 unsigned char val6 ;
15892 int ecode6 = 0 ;
15893 unsigned char val7 ;
15894 int ecode7 = 0 ;
15895 PyObject * obj0 = 0 ;
15896 PyObject * obj1 = 0 ;
15897 PyObject * obj2 = 0 ;
15898 PyObject * obj3 = 0 ;
15899 PyObject * obj4 = 0 ;
15900 PyObject * obj5 = 0 ;
15901 PyObject * obj6 = 0 ;
15902 char * kwnames[] = {
15903 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15904 };
15905
15906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15908 if (!SWIG_IsOK(res1)) {
15909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15910 }
15911 arg1 = reinterpret_cast< wxImage * >(argp1);
15912 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15913 if (!SWIG_IsOK(ecode2)) {
15914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15915 }
15916 arg2 = static_cast< byte >(val2);
15917 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15918 if (!SWIG_IsOK(ecode3)) {
15919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15920 }
15921 arg3 = static_cast< byte >(val3);
15922 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15923 if (!SWIG_IsOK(ecode4)) {
15924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15925 }
15926 arg4 = static_cast< byte >(val4);
15927 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15928 if (!SWIG_IsOK(ecode5)) {
15929 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15930 }
15931 arg5 = static_cast< byte >(val5);
15932 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
15933 if (!SWIG_IsOK(ecode6)) {
15934 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
15935 }
15936 arg6 = static_cast< byte >(val6);
15937 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
15938 if (!SWIG_IsOK(ecode7)) {
15939 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
15940 }
15941 arg7 = static_cast< byte >(val7);
15942 {
15943 PyThreadState* __tstate = wxPyBeginAllowThreads();
15944 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
15945 wxPyEndAllowThreads(__tstate);
15946 if (PyErr_Occurred()) SWIG_fail;
15947 }
15948 resultobj = SWIG_Py_Void();
15949 return resultobj;
15950 fail:
15951 return NULL;
15952 }
15953
15954
15955 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15956 PyObject *resultobj = 0;
15957 wxImage *arg1 = (wxImage *) 0 ;
15958 double arg2 = (double) 0.299 ;
15959 double arg3 = (double) 0.587 ;
15960 double arg4 = (double) 0.114 ;
15961 SwigValueWrapper<wxImage > result;
15962 void *argp1 = 0 ;
15963 int res1 = 0 ;
15964 double val2 ;
15965 int ecode2 = 0 ;
15966 double val3 ;
15967 int ecode3 = 0 ;
15968 double val4 ;
15969 int ecode4 = 0 ;
15970 PyObject * obj0 = 0 ;
15971 PyObject * obj1 = 0 ;
15972 PyObject * obj2 = 0 ;
15973 PyObject * obj3 = 0 ;
15974 char * kwnames[] = {
15975 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
15976 };
15977
15978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15980 if (!SWIG_IsOK(res1)) {
15981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
15982 }
15983 arg1 = reinterpret_cast< wxImage * >(argp1);
15984 if (obj1) {
15985 ecode2 = SWIG_AsVal_double(obj1, &val2);
15986 if (!SWIG_IsOK(ecode2)) {
15987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
15988 }
15989 arg2 = static_cast< double >(val2);
15990 }
15991 if (obj2) {
15992 ecode3 = SWIG_AsVal_double(obj2, &val3);
15993 if (!SWIG_IsOK(ecode3)) {
15994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
15995 }
15996 arg3 = static_cast< double >(val3);
15997 }
15998 if (obj3) {
15999 ecode4 = SWIG_AsVal_double(obj3, &val4);
16000 if (!SWIG_IsOK(ecode4)) {
16001 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16002 }
16003 arg4 = static_cast< double >(val4);
16004 }
16005 {
16006 PyThreadState* __tstate = wxPyBeginAllowThreads();
16007 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16008 wxPyEndAllowThreads(__tstate);
16009 if (PyErr_Occurred()) SWIG_fail;
16010 }
16011 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16012 return resultobj;
16013 fail:
16014 return NULL;
16015 }
16016
16017
16018 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16019 PyObject *resultobj = 0;
16020 wxImage *arg1 = (wxImage *) 0 ;
16021 byte arg2 ;
16022 byte arg3 ;
16023 byte arg4 ;
16024 SwigValueWrapper<wxImage > result;
16025 void *argp1 = 0 ;
16026 int res1 = 0 ;
16027 unsigned char val2 ;
16028 int ecode2 = 0 ;
16029 unsigned char val3 ;
16030 int ecode3 = 0 ;
16031 unsigned char val4 ;
16032 int ecode4 = 0 ;
16033 PyObject * obj0 = 0 ;
16034 PyObject * obj1 = 0 ;
16035 PyObject * obj2 = 0 ;
16036 PyObject * obj3 = 0 ;
16037 char * kwnames[] = {
16038 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16039 };
16040
16041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16043 if (!SWIG_IsOK(res1)) {
16044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16045 }
16046 arg1 = reinterpret_cast< wxImage * >(argp1);
16047 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16048 if (!SWIG_IsOK(ecode2)) {
16049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16050 }
16051 arg2 = static_cast< byte >(val2);
16052 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16053 if (!SWIG_IsOK(ecode3)) {
16054 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16055 }
16056 arg3 = static_cast< byte >(val3);
16057 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16058 if (!SWIG_IsOK(ecode4)) {
16059 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16060 }
16061 arg4 = static_cast< byte >(val4);
16062 {
16063 PyThreadState* __tstate = wxPyBeginAllowThreads();
16064 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16065 wxPyEndAllowThreads(__tstate);
16066 if (PyErr_Occurred()) SWIG_fail;
16067 }
16068 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16069 return resultobj;
16070 fail:
16071 return NULL;
16072 }
16073
16074
16075 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16076 PyObject *resultobj = 0;
16077 wxImage *arg1 = (wxImage *) 0 ;
16078 wxString *arg2 = 0 ;
16079 wxString *arg3 = 0 ;
16080 void *argp1 = 0 ;
16081 int res1 = 0 ;
16082 bool temp2 = false ;
16083 bool temp3 = false ;
16084 PyObject * obj0 = 0 ;
16085 PyObject * obj1 = 0 ;
16086 PyObject * obj2 = 0 ;
16087 char * kwnames[] = {
16088 (char *) "self",(char *) "name",(char *) "value", NULL
16089 };
16090
16091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16093 if (!SWIG_IsOK(res1)) {
16094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16095 }
16096 arg1 = reinterpret_cast< wxImage * >(argp1);
16097 {
16098 arg2 = wxString_in_helper(obj1);
16099 if (arg2 == NULL) SWIG_fail;
16100 temp2 = true;
16101 }
16102 {
16103 arg3 = wxString_in_helper(obj2);
16104 if (arg3 == NULL) SWIG_fail;
16105 temp3 = true;
16106 }
16107 {
16108 PyThreadState* __tstate = wxPyBeginAllowThreads();
16109 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16110 wxPyEndAllowThreads(__tstate);
16111 if (PyErr_Occurred()) SWIG_fail;
16112 }
16113 resultobj = SWIG_Py_Void();
16114 {
16115 if (temp2)
16116 delete arg2;
16117 }
16118 {
16119 if (temp3)
16120 delete arg3;
16121 }
16122 return resultobj;
16123 fail:
16124 {
16125 if (temp2)
16126 delete arg2;
16127 }
16128 {
16129 if (temp3)
16130 delete arg3;
16131 }
16132 return NULL;
16133 }
16134
16135
16136 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16137 PyObject *resultobj = 0;
16138 wxImage *arg1 = (wxImage *) 0 ;
16139 wxString *arg2 = 0 ;
16140 int arg3 ;
16141 void *argp1 = 0 ;
16142 int res1 = 0 ;
16143 bool temp2 = false ;
16144 int val3 ;
16145 int ecode3 = 0 ;
16146 PyObject * obj0 = 0 ;
16147 PyObject * obj1 = 0 ;
16148 PyObject * obj2 = 0 ;
16149 char * kwnames[] = {
16150 (char *) "self",(char *) "name",(char *) "value", NULL
16151 };
16152
16153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16155 if (!SWIG_IsOK(res1)) {
16156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16157 }
16158 arg1 = reinterpret_cast< wxImage * >(argp1);
16159 {
16160 arg2 = wxString_in_helper(obj1);
16161 if (arg2 == NULL) SWIG_fail;
16162 temp2 = true;
16163 }
16164 ecode3 = SWIG_AsVal_int(obj2, &val3);
16165 if (!SWIG_IsOK(ecode3)) {
16166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16167 }
16168 arg3 = static_cast< int >(val3);
16169 {
16170 PyThreadState* __tstate = wxPyBeginAllowThreads();
16171 (arg1)->SetOption((wxString const &)*arg2,arg3);
16172 wxPyEndAllowThreads(__tstate);
16173 if (PyErr_Occurred()) SWIG_fail;
16174 }
16175 resultobj = SWIG_Py_Void();
16176 {
16177 if (temp2)
16178 delete arg2;
16179 }
16180 return resultobj;
16181 fail:
16182 {
16183 if (temp2)
16184 delete arg2;
16185 }
16186 return NULL;
16187 }
16188
16189
16190 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16191 PyObject *resultobj = 0;
16192 wxImage *arg1 = (wxImage *) 0 ;
16193 wxString *arg2 = 0 ;
16194 wxString result;
16195 void *argp1 = 0 ;
16196 int res1 = 0 ;
16197 bool temp2 = false ;
16198 PyObject * obj0 = 0 ;
16199 PyObject * obj1 = 0 ;
16200 char * kwnames[] = {
16201 (char *) "self",(char *) "name", NULL
16202 };
16203
16204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16206 if (!SWIG_IsOK(res1)) {
16207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16208 }
16209 arg1 = reinterpret_cast< wxImage * >(argp1);
16210 {
16211 arg2 = wxString_in_helper(obj1);
16212 if (arg2 == NULL) SWIG_fail;
16213 temp2 = true;
16214 }
16215 {
16216 PyThreadState* __tstate = wxPyBeginAllowThreads();
16217 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16218 wxPyEndAllowThreads(__tstate);
16219 if (PyErr_Occurred()) SWIG_fail;
16220 }
16221 {
16222 #if wxUSE_UNICODE
16223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16224 #else
16225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16226 #endif
16227 }
16228 {
16229 if (temp2)
16230 delete arg2;
16231 }
16232 return resultobj;
16233 fail:
16234 {
16235 if (temp2)
16236 delete arg2;
16237 }
16238 return NULL;
16239 }
16240
16241
16242 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16243 PyObject *resultobj = 0;
16244 wxImage *arg1 = (wxImage *) 0 ;
16245 wxString *arg2 = 0 ;
16246 int result;
16247 void *argp1 = 0 ;
16248 int res1 = 0 ;
16249 bool temp2 = false ;
16250 PyObject * obj0 = 0 ;
16251 PyObject * obj1 = 0 ;
16252 char * kwnames[] = {
16253 (char *) "self",(char *) "name", NULL
16254 };
16255
16256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16258 if (!SWIG_IsOK(res1)) {
16259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16260 }
16261 arg1 = reinterpret_cast< wxImage * >(argp1);
16262 {
16263 arg2 = wxString_in_helper(obj1);
16264 if (arg2 == NULL) SWIG_fail;
16265 temp2 = true;
16266 }
16267 {
16268 PyThreadState* __tstate = wxPyBeginAllowThreads();
16269 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16270 wxPyEndAllowThreads(__tstate);
16271 if (PyErr_Occurred()) SWIG_fail;
16272 }
16273 resultobj = SWIG_From_int(static_cast< int >(result));
16274 {
16275 if (temp2)
16276 delete arg2;
16277 }
16278 return resultobj;
16279 fail:
16280 {
16281 if (temp2)
16282 delete arg2;
16283 }
16284 return NULL;
16285 }
16286
16287
16288 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16289 PyObject *resultobj = 0;
16290 wxImage *arg1 = (wxImage *) 0 ;
16291 wxString *arg2 = 0 ;
16292 bool result;
16293 void *argp1 = 0 ;
16294 int res1 = 0 ;
16295 bool temp2 = false ;
16296 PyObject * obj0 = 0 ;
16297 PyObject * obj1 = 0 ;
16298 char * kwnames[] = {
16299 (char *) "self",(char *) "name", NULL
16300 };
16301
16302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16304 if (!SWIG_IsOK(res1)) {
16305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16306 }
16307 arg1 = reinterpret_cast< wxImage * >(argp1);
16308 {
16309 arg2 = wxString_in_helper(obj1);
16310 if (arg2 == NULL) SWIG_fail;
16311 temp2 = true;
16312 }
16313 {
16314 PyThreadState* __tstate = wxPyBeginAllowThreads();
16315 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16316 wxPyEndAllowThreads(__tstate);
16317 if (PyErr_Occurred()) SWIG_fail;
16318 }
16319 {
16320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16321 }
16322 {
16323 if (temp2)
16324 delete arg2;
16325 }
16326 return resultobj;
16327 fail:
16328 {
16329 if (temp2)
16330 delete arg2;
16331 }
16332 return NULL;
16333 }
16334
16335
16336 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16337 PyObject *resultobj = 0;
16338 wxImage *arg1 = (wxImage *) 0 ;
16339 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16340 unsigned long result;
16341 void *argp1 = 0 ;
16342 int res1 = 0 ;
16343 unsigned long val2 ;
16344 int ecode2 = 0 ;
16345 PyObject * obj0 = 0 ;
16346 PyObject * obj1 = 0 ;
16347 char * kwnames[] = {
16348 (char *) "self",(char *) "stopafter", NULL
16349 };
16350
16351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16353 if (!SWIG_IsOK(res1)) {
16354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16355 }
16356 arg1 = reinterpret_cast< wxImage * >(argp1);
16357 if (obj1) {
16358 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16359 if (!SWIG_IsOK(ecode2)) {
16360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16361 }
16362 arg2 = static_cast< unsigned long >(val2);
16363 }
16364 {
16365 PyThreadState* __tstate = wxPyBeginAllowThreads();
16366 result = (unsigned long)(arg1)->CountColours(arg2);
16367 wxPyEndAllowThreads(__tstate);
16368 if (PyErr_Occurred()) SWIG_fail;
16369 }
16370 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16371 return resultobj;
16372 fail:
16373 return NULL;
16374 }
16375
16376
16377 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16378 PyObject *resultobj = 0;
16379 wxImage *arg1 = (wxImage *) 0 ;
16380 wxImageHistogram *arg2 = 0 ;
16381 unsigned long result;
16382 void *argp1 = 0 ;
16383 int res1 = 0 ;
16384 void *argp2 = 0 ;
16385 int res2 = 0 ;
16386 PyObject * obj0 = 0 ;
16387 PyObject * obj1 = 0 ;
16388 char * kwnames[] = {
16389 (char *) "self",(char *) "h", NULL
16390 };
16391
16392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16394 if (!SWIG_IsOK(res1)) {
16395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16396 }
16397 arg1 = reinterpret_cast< wxImage * >(argp1);
16398 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16399 if (!SWIG_IsOK(res2)) {
16400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16401 }
16402 if (!argp2) {
16403 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16404 }
16405 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16406 {
16407 PyThreadState* __tstate = wxPyBeginAllowThreads();
16408 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16409 wxPyEndAllowThreads(__tstate);
16410 if (PyErr_Occurred()) SWIG_fail;
16411 }
16412 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16413 return resultobj;
16414 fail:
16415 return NULL;
16416 }
16417
16418
16419 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16420 PyObject *resultobj = 0;
16421 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16422 void *argp1 = 0 ;
16423 int res1 = 0 ;
16424 PyObject * obj0 = 0 ;
16425 char * kwnames[] = {
16426 (char *) "handler", NULL
16427 };
16428
16429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16431 if (!SWIG_IsOK(res1)) {
16432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16433 }
16434 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16435 {
16436 PyThreadState* __tstate = wxPyBeginAllowThreads();
16437 wxImage::AddHandler(arg1);
16438 wxPyEndAllowThreads(__tstate);
16439 if (PyErr_Occurred()) SWIG_fail;
16440 }
16441 resultobj = SWIG_Py_Void();
16442 return resultobj;
16443 fail:
16444 return NULL;
16445 }
16446
16447
16448 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16449 PyObject *resultobj = 0;
16450 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16451 void *argp1 = 0 ;
16452 int res1 = 0 ;
16453 PyObject * obj0 = 0 ;
16454 char * kwnames[] = {
16455 (char *) "handler", NULL
16456 };
16457
16458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16460 if (!SWIG_IsOK(res1)) {
16461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16462 }
16463 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16464 {
16465 PyThreadState* __tstate = wxPyBeginAllowThreads();
16466 wxImage::InsertHandler(arg1);
16467 wxPyEndAllowThreads(__tstate);
16468 if (PyErr_Occurred()) SWIG_fail;
16469 }
16470 resultobj = SWIG_Py_Void();
16471 return resultobj;
16472 fail:
16473 return NULL;
16474 }
16475
16476
16477 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16478 PyObject *resultobj = 0;
16479 wxString *arg1 = 0 ;
16480 bool result;
16481 bool temp1 = false ;
16482 PyObject * obj0 = 0 ;
16483 char * kwnames[] = {
16484 (char *) "name", NULL
16485 };
16486
16487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16488 {
16489 arg1 = wxString_in_helper(obj0);
16490 if (arg1 == NULL) SWIG_fail;
16491 temp1 = true;
16492 }
16493 {
16494 PyThreadState* __tstate = wxPyBeginAllowThreads();
16495 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16496 wxPyEndAllowThreads(__tstate);
16497 if (PyErr_Occurred()) SWIG_fail;
16498 }
16499 {
16500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16501 }
16502 {
16503 if (temp1)
16504 delete arg1;
16505 }
16506 return resultobj;
16507 fail:
16508 {
16509 if (temp1)
16510 delete arg1;
16511 }
16512 return NULL;
16513 }
16514
16515
16516 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16517 PyObject *resultobj = 0;
16518 PyObject *result = 0 ;
16519
16520 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16521 {
16522 PyThreadState* __tstate = wxPyBeginAllowThreads();
16523 result = (PyObject *)wxImage_GetHandlers();
16524 wxPyEndAllowThreads(__tstate);
16525 if (PyErr_Occurred()) SWIG_fail;
16526 }
16527 resultobj = result;
16528 return resultobj;
16529 fail:
16530 return NULL;
16531 }
16532
16533
16534 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16535 PyObject *resultobj = 0;
16536 wxString result;
16537
16538 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16539 {
16540 PyThreadState* __tstate = wxPyBeginAllowThreads();
16541 result = wxImage::GetImageExtWildcard();
16542 wxPyEndAllowThreads(__tstate);
16543 if (PyErr_Occurred()) SWIG_fail;
16544 }
16545 {
16546 #if wxUSE_UNICODE
16547 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16548 #else
16549 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16550 #endif
16551 }
16552 return resultobj;
16553 fail:
16554 return NULL;
16555 }
16556
16557
16558 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16559 PyObject *resultobj = 0;
16560 wxImage *arg1 = (wxImage *) 0 ;
16561 int arg2 = (int) -1 ;
16562 wxBitmap result;
16563 void *argp1 = 0 ;
16564 int res1 = 0 ;
16565 int val2 ;
16566 int ecode2 = 0 ;
16567 PyObject * obj0 = 0 ;
16568 PyObject * obj1 = 0 ;
16569 char * kwnames[] = {
16570 (char *) "self",(char *) "depth", NULL
16571 };
16572
16573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16575 if (!SWIG_IsOK(res1)) {
16576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16577 }
16578 arg1 = reinterpret_cast< wxImage * >(argp1);
16579 if (obj1) {
16580 ecode2 = SWIG_AsVal_int(obj1, &val2);
16581 if (!SWIG_IsOK(ecode2)) {
16582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16583 }
16584 arg2 = static_cast< int >(val2);
16585 }
16586 {
16587 if (!wxPyCheckForApp()) SWIG_fail;
16588 PyThreadState* __tstate = wxPyBeginAllowThreads();
16589 result = wxImage_ConvertToBitmap(arg1,arg2);
16590 wxPyEndAllowThreads(__tstate);
16591 if (PyErr_Occurred()) SWIG_fail;
16592 }
16593 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16594 return resultobj;
16595 fail:
16596 return NULL;
16597 }
16598
16599
16600 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16601 PyObject *resultobj = 0;
16602 wxImage *arg1 = (wxImage *) 0 ;
16603 byte arg2 ;
16604 byte arg3 ;
16605 byte arg4 ;
16606 wxBitmap result;
16607 void *argp1 = 0 ;
16608 int res1 = 0 ;
16609 unsigned char val2 ;
16610 int ecode2 = 0 ;
16611 unsigned char val3 ;
16612 int ecode3 = 0 ;
16613 unsigned char val4 ;
16614 int ecode4 = 0 ;
16615 PyObject * obj0 = 0 ;
16616 PyObject * obj1 = 0 ;
16617 PyObject * obj2 = 0 ;
16618 PyObject * obj3 = 0 ;
16619 char * kwnames[] = {
16620 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16621 };
16622
16623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16625 if (!SWIG_IsOK(res1)) {
16626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16627 }
16628 arg1 = reinterpret_cast< wxImage * >(argp1);
16629 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16630 if (!SWIG_IsOK(ecode2)) {
16631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16632 }
16633 arg2 = static_cast< byte >(val2);
16634 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16635 if (!SWIG_IsOK(ecode3)) {
16636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16637 }
16638 arg3 = static_cast< byte >(val3);
16639 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16640 if (!SWIG_IsOK(ecode4)) {
16641 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16642 }
16643 arg4 = static_cast< byte >(val4);
16644 {
16645 if (!wxPyCheckForApp()) SWIG_fail;
16646 PyThreadState* __tstate = wxPyBeginAllowThreads();
16647 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16648 wxPyEndAllowThreads(__tstate);
16649 if (PyErr_Occurred()) SWIG_fail;
16650 }
16651 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16652 return resultobj;
16653 fail:
16654 return NULL;
16655 }
16656
16657
16658 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16659 PyObject *resultobj = 0;
16660 wxImage *arg1 = (wxImage *) 0 ;
16661 double arg2 ;
16662 void *argp1 = 0 ;
16663 int res1 = 0 ;
16664 double val2 ;
16665 int ecode2 = 0 ;
16666 PyObject * obj0 = 0 ;
16667 PyObject * obj1 = 0 ;
16668 char * kwnames[] = {
16669 (char *) "self",(char *) "angle", NULL
16670 };
16671
16672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16674 if (!SWIG_IsOK(res1)) {
16675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16676 }
16677 arg1 = reinterpret_cast< wxImage * >(argp1);
16678 ecode2 = SWIG_AsVal_double(obj1, &val2);
16679 if (!SWIG_IsOK(ecode2)) {
16680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16681 }
16682 arg2 = static_cast< double >(val2);
16683 {
16684 PyThreadState* __tstate = wxPyBeginAllowThreads();
16685 (arg1)->RotateHue(arg2);
16686 wxPyEndAllowThreads(__tstate);
16687 if (PyErr_Occurred()) SWIG_fail;
16688 }
16689 resultobj = SWIG_Py_Void();
16690 return resultobj;
16691 fail:
16692 return NULL;
16693 }
16694
16695
16696 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16697 PyObject *resultobj = 0;
16698 wxImage_RGBValue arg1 ;
16699 wxImage_HSVValue result;
16700 void *argp1 ;
16701 int res1 = 0 ;
16702 PyObject * obj0 = 0 ;
16703 char * kwnames[] = {
16704 (char *) "rgb", NULL
16705 };
16706
16707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16708 {
16709 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16710 if (!SWIG_IsOK(res1)) {
16711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16712 }
16713 if (!argp1) {
16714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16715 } else {
16716 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16717 arg1 = *temp;
16718 if (SWIG_IsNewObj(res1)) delete temp;
16719 }
16720 }
16721 {
16722 PyThreadState* __tstate = wxPyBeginAllowThreads();
16723 result = wxImage::RGBtoHSV(arg1);
16724 wxPyEndAllowThreads(__tstate);
16725 if (PyErr_Occurred()) SWIG_fail;
16726 }
16727 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16728 return resultobj;
16729 fail:
16730 return NULL;
16731 }
16732
16733
16734 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16735 PyObject *resultobj = 0;
16736 wxImage_HSVValue arg1 ;
16737 wxImage_RGBValue result;
16738 void *argp1 ;
16739 int res1 = 0 ;
16740 PyObject * obj0 = 0 ;
16741 char * kwnames[] = {
16742 (char *) "hsv", NULL
16743 };
16744
16745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16746 {
16747 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16748 if (!SWIG_IsOK(res1)) {
16749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16750 }
16751 if (!argp1) {
16752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16753 } else {
16754 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16755 arg1 = *temp;
16756 if (SWIG_IsNewObj(res1)) delete temp;
16757 }
16758 }
16759 {
16760 PyThreadState* __tstate = wxPyBeginAllowThreads();
16761 result = wxImage::HSVtoRGB(arg1);
16762 wxPyEndAllowThreads(__tstate);
16763 if (PyErr_Occurred()) SWIG_fail;
16764 }
16765 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16766 return resultobj;
16767 fail:
16768 return NULL;
16769 }
16770
16771
16772 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16773 PyObject *obj;
16774 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16775 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16776 return SWIG_Py_Void();
16777 }
16778
16779 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16780 return SWIG_Python_InitShadowInstance(args);
16781 }
16782
16783 SWIGINTERN int NullImage_set(PyObject *) {
16784 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16785 return 1;
16786 }
16787
16788
16789 SWIGINTERN PyObject *NullImage_get(void) {
16790 PyObject *pyobj = 0;
16791
16792 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16793 return pyobj;
16794 }
16795
16796
16797 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16798 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16799 return 1;
16800 }
16801
16802
16803 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16804 PyObject *pyobj = 0;
16805
16806 {
16807 #if wxUSE_UNICODE
16808 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16809 #else
16810 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16811 #endif
16812 }
16813 return pyobj;
16814 }
16815
16816
16817 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16818 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16819 return 1;
16820 }
16821
16822
16823 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16824 PyObject *pyobj = 0;
16825
16826 {
16827 #if wxUSE_UNICODE
16828 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16829 #else
16830 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16831 #endif
16832 }
16833 return pyobj;
16834 }
16835
16836
16837 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16838 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16839 return 1;
16840 }
16841
16842
16843 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16844 PyObject *pyobj = 0;
16845
16846 {
16847 #if wxUSE_UNICODE
16848 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16849 #else
16850 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16851 #endif
16852 }
16853 return pyobj;
16854 }
16855
16856
16857 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16858 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16859 return 1;
16860 }
16861
16862
16863 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16864 PyObject *pyobj = 0;
16865
16866 {
16867 #if wxUSE_UNICODE
16868 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16869 #else
16870 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16871 #endif
16872 }
16873 return pyobj;
16874 }
16875
16876
16877 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16878 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16879 return 1;
16880 }
16881
16882
16883 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16884 PyObject *pyobj = 0;
16885
16886 {
16887 #if wxUSE_UNICODE
16888 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16889 #else
16890 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16891 #endif
16892 }
16893 return pyobj;
16894 }
16895
16896
16897 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16898 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16899 return 1;
16900 }
16901
16902
16903 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16904 PyObject *pyobj = 0;
16905
16906 {
16907 #if wxUSE_UNICODE
16908 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16909 #else
16910 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16911 #endif
16912 }
16913 return pyobj;
16914 }
16915
16916
16917 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16918 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16919 return 1;
16920 }
16921
16922
16923 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16924 PyObject *pyobj = 0;
16925
16926 {
16927 #if wxUSE_UNICODE
16928 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16929 #else
16930 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16931 #endif
16932 }
16933 return pyobj;
16934 }
16935
16936
16937 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
16938 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
16939 return 1;
16940 }
16941
16942
16943 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
16944 PyObject *pyobj = 0;
16945
16946 {
16947 #if wxUSE_UNICODE
16948 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16949 #else
16950 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16951 #endif
16952 }
16953 return pyobj;
16954 }
16955
16956
16957 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
16958 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
16959 return 1;
16960 }
16961
16962
16963 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
16964 PyObject *pyobj = 0;
16965
16966 {
16967 #if wxUSE_UNICODE
16968 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16969 #else
16970 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16971 #endif
16972 }
16973 return pyobj;
16974 }
16975
16976
16977 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
16978 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
16979 return 1;
16980 }
16981
16982
16983 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
16984 PyObject *pyobj = 0;
16985
16986 {
16987 #if wxUSE_UNICODE
16988 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16989 #else
16990 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16991 #endif
16992 }
16993 return pyobj;
16994 }
16995
16996
16997 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
16998 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
16999 return 1;
17000 }
17001
17002
17003 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17004 PyObject *pyobj = 0;
17005
17006 {
17007 #if wxUSE_UNICODE
17008 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17009 #else
17010 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17011 #endif
17012 }
17013 return pyobj;
17014 }
17015
17016
17017 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17018 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17019 return 1;
17020 }
17021
17022
17023 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17024 PyObject *pyobj = 0;
17025
17026 {
17027 #if wxUSE_UNICODE
17028 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17029 #else
17030 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17031 #endif
17032 }
17033 return pyobj;
17034 }
17035
17036
17037 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17038 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17039 return 1;
17040 }
17041
17042
17043 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17044 PyObject *pyobj = 0;
17045
17046 {
17047 #if wxUSE_UNICODE
17048 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17049 #else
17050 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17051 #endif
17052 }
17053 return pyobj;
17054 }
17055
17056
17057 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17058 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17059 return 1;
17060 }
17061
17062
17063 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17064 PyObject *pyobj = 0;
17065
17066 {
17067 #if wxUSE_UNICODE
17068 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17069 #else
17070 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17071 #endif
17072 }
17073 return pyobj;
17074 }
17075
17076
17077 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17078 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17079 return 1;
17080 }
17081
17082
17083 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17084 PyObject *pyobj = 0;
17085
17086 {
17087 #if wxUSE_UNICODE
17088 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17089 #else
17090 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17091 #endif
17092 }
17093 return pyobj;
17094 }
17095
17096
17097 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17098 PyObject *resultobj = 0;
17099 wxBMPHandler *result = 0 ;
17100
17101 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17102 {
17103 PyThreadState* __tstate = wxPyBeginAllowThreads();
17104 result = (wxBMPHandler *)new wxBMPHandler();
17105 wxPyEndAllowThreads(__tstate);
17106 if (PyErr_Occurred()) SWIG_fail;
17107 }
17108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17109 return resultobj;
17110 fail:
17111 return NULL;
17112 }
17113
17114
17115 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17116 PyObject *obj;
17117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17118 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17119 return SWIG_Py_Void();
17120 }
17121
17122 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17123 return SWIG_Python_InitShadowInstance(args);
17124 }
17125
17126 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17127 PyObject *resultobj = 0;
17128 wxICOHandler *result = 0 ;
17129
17130 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17131 {
17132 PyThreadState* __tstate = wxPyBeginAllowThreads();
17133 result = (wxICOHandler *)new wxICOHandler();
17134 wxPyEndAllowThreads(__tstate);
17135 if (PyErr_Occurred()) SWIG_fail;
17136 }
17137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17138 return resultobj;
17139 fail:
17140 return NULL;
17141 }
17142
17143
17144 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17145 PyObject *obj;
17146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17147 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17148 return SWIG_Py_Void();
17149 }
17150
17151 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17152 return SWIG_Python_InitShadowInstance(args);
17153 }
17154
17155 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17156 PyObject *resultobj = 0;
17157 wxCURHandler *result = 0 ;
17158
17159 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17160 {
17161 PyThreadState* __tstate = wxPyBeginAllowThreads();
17162 result = (wxCURHandler *)new wxCURHandler();
17163 wxPyEndAllowThreads(__tstate);
17164 if (PyErr_Occurred()) SWIG_fail;
17165 }
17166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17167 return resultobj;
17168 fail:
17169 return NULL;
17170 }
17171
17172
17173 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17174 PyObject *obj;
17175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17176 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17177 return SWIG_Py_Void();
17178 }
17179
17180 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17181 return SWIG_Python_InitShadowInstance(args);
17182 }
17183
17184 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17185 PyObject *resultobj = 0;
17186 wxANIHandler *result = 0 ;
17187
17188 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17189 {
17190 PyThreadState* __tstate = wxPyBeginAllowThreads();
17191 result = (wxANIHandler *)new wxANIHandler();
17192 wxPyEndAllowThreads(__tstate);
17193 if (PyErr_Occurred()) SWIG_fail;
17194 }
17195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17196 return resultobj;
17197 fail:
17198 return NULL;
17199 }
17200
17201
17202 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17203 PyObject *obj;
17204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17205 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17206 return SWIG_Py_Void();
17207 }
17208
17209 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17210 return SWIG_Python_InitShadowInstance(args);
17211 }
17212
17213 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17214 PyObject *resultobj = 0;
17215 wxPNGHandler *result = 0 ;
17216
17217 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17218 {
17219 PyThreadState* __tstate = wxPyBeginAllowThreads();
17220 result = (wxPNGHandler *)new wxPNGHandler();
17221 wxPyEndAllowThreads(__tstate);
17222 if (PyErr_Occurred()) SWIG_fail;
17223 }
17224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17225 return resultobj;
17226 fail:
17227 return NULL;
17228 }
17229
17230
17231 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17232 PyObject *obj;
17233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17234 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17235 return SWIG_Py_Void();
17236 }
17237
17238 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17239 return SWIG_Python_InitShadowInstance(args);
17240 }
17241
17242 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17243 PyObject *resultobj = 0;
17244 wxGIFHandler *result = 0 ;
17245
17246 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17247 {
17248 PyThreadState* __tstate = wxPyBeginAllowThreads();
17249 result = (wxGIFHandler *)new wxGIFHandler();
17250 wxPyEndAllowThreads(__tstate);
17251 if (PyErr_Occurred()) SWIG_fail;
17252 }
17253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17254 return resultobj;
17255 fail:
17256 return NULL;
17257 }
17258
17259
17260 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17261 PyObject *obj;
17262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17263 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17264 return SWIG_Py_Void();
17265 }
17266
17267 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17268 return SWIG_Python_InitShadowInstance(args);
17269 }
17270
17271 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17272 PyObject *resultobj = 0;
17273 wxPCXHandler *result = 0 ;
17274
17275 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17276 {
17277 PyThreadState* __tstate = wxPyBeginAllowThreads();
17278 result = (wxPCXHandler *)new wxPCXHandler();
17279 wxPyEndAllowThreads(__tstate);
17280 if (PyErr_Occurred()) SWIG_fail;
17281 }
17282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17283 return resultobj;
17284 fail:
17285 return NULL;
17286 }
17287
17288
17289 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17290 PyObject *obj;
17291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17292 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17293 return SWIG_Py_Void();
17294 }
17295
17296 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17297 return SWIG_Python_InitShadowInstance(args);
17298 }
17299
17300 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17301 PyObject *resultobj = 0;
17302 wxJPEGHandler *result = 0 ;
17303
17304 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17305 {
17306 PyThreadState* __tstate = wxPyBeginAllowThreads();
17307 result = (wxJPEGHandler *)new wxJPEGHandler();
17308 wxPyEndAllowThreads(__tstate);
17309 if (PyErr_Occurred()) SWIG_fail;
17310 }
17311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17312 return resultobj;
17313 fail:
17314 return NULL;
17315 }
17316
17317
17318 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17319 PyObject *obj;
17320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17321 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17322 return SWIG_Py_Void();
17323 }
17324
17325 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17326 return SWIG_Python_InitShadowInstance(args);
17327 }
17328
17329 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17330 PyObject *resultobj = 0;
17331 wxPNMHandler *result = 0 ;
17332
17333 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17334 {
17335 PyThreadState* __tstate = wxPyBeginAllowThreads();
17336 result = (wxPNMHandler *)new wxPNMHandler();
17337 wxPyEndAllowThreads(__tstate);
17338 if (PyErr_Occurred()) SWIG_fail;
17339 }
17340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17341 return resultobj;
17342 fail:
17343 return NULL;
17344 }
17345
17346
17347 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17348 PyObject *obj;
17349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17350 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17351 return SWIG_Py_Void();
17352 }
17353
17354 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17355 return SWIG_Python_InitShadowInstance(args);
17356 }
17357
17358 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17359 PyObject *resultobj = 0;
17360 wxXPMHandler *result = 0 ;
17361
17362 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17363 {
17364 PyThreadState* __tstate = wxPyBeginAllowThreads();
17365 result = (wxXPMHandler *)new wxXPMHandler();
17366 wxPyEndAllowThreads(__tstate);
17367 if (PyErr_Occurred()) SWIG_fail;
17368 }
17369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17370 return resultobj;
17371 fail:
17372 return NULL;
17373 }
17374
17375
17376 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17377 PyObject *obj;
17378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17379 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17380 return SWIG_Py_Void();
17381 }
17382
17383 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17384 return SWIG_Python_InitShadowInstance(args);
17385 }
17386
17387 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17388 PyObject *resultobj = 0;
17389 wxTIFFHandler *result = 0 ;
17390
17391 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17392 {
17393 PyThreadState* __tstate = wxPyBeginAllowThreads();
17394 result = (wxTIFFHandler *)new wxTIFFHandler();
17395 wxPyEndAllowThreads(__tstate);
17396 if (PyErr_Occurred()) SWIG_fail;
17397 }
17398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17399 return resultobj;
17400 fail:
17401 return NULL;
17402 }
17403
17404
17405 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17406 PyObject *obj;
17407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17408 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17409 return SWIG_Py_Void();
17410 }
17411
17412 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17413 return SWIG_Python_InitShadowInstance(args);
17414 }
17415
17416 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17417 PyObject *resultobj = 0;
17418 wxImage *arg1 = 0 ;
17419 wxImage *arg2 = 0 ;
17420 int arg3 = (int) 236 ;
17421 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17422 bool result;
17423 void *argp1 = 0 ;
17424 int res1 = 0 ;
17425 void *argp2 = 0 ;
17426 int res2 = 0 ;
17427 int val3 ;
17428 int ecode3 = 0 ;
17429 int val4 ;
17430 int ecode4 = 0 ;
17431 PyObject * obj0 = 0 ;
17432 PyObject * obj1 = 0 ;
17433 PyObject * obj2 = 0 ;
17434 PyObject * obj3 = 0 ;
17435 char * kwnames[] = {
17436 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17437 };
17438
17439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17440 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17441 if (!SWIG_IsOK(res1)) {
17442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17443 }
17444 if (!argp1) {
17445 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17446 }
17447 arg1 = reinterpret_cast< wxImage * >(argp1);
17448 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17449 if (!SWIG_IsOK(res2)) {
17450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17451 }
17452 if (!argp2) {
17453 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17454 }
17455 arg2 = reinterpret_cast< wxImage * >(argp2);
17456 if (obj2) {
17457 ecode3 = SWIG_AsVal_int(obj2, &val3);
17458 if (!SWIG_IsOK(ecode3)) {
17459 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17460 }
17461 arg3 = static_cast< int >(val3);
17462 }
17463 if (obj3) {
17464 ecode4 = SWIG_AsVal_int(obj3, &val4);
17465 if (!SWIG_IsOK(ecode4)) {
17466 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17467 }
17468 arg4 = static_cast< int >(val4);
17469 }
17470 {
17471 PyThreadState* __tstate = wxPyBeginAllowThreads();
17472 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17473 wxPyEndAllowThreads(__tstate);
17474 if (PyErr_Occurred()) SWIG_fail;
17475 }
17476 {
17477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17478 }
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17486 PyObject *obj;
17487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17488 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17489 return SWIG_Py_Void();
17490 }
17491
17492 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17493 PyObject *resultobj = 0;
17494 wxEvtHandler *result = 0 ;
17495
17496 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17497 {
17498 PyThreadState* __tstate = wxPyBeginAllowThreads();
17499 result = (wxEvtHandler *)new wxEvtHandler();
17500 wxPyEndAllowThreads(__tstate);
17501 if (PyErr_Occurred()) SWIG_fail;
17502 }
17503 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17504 return resultobj;
17505 fail:
17506 return NULL;
17507 }
17508
17509
17510 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17511 PyObject *resultobj = 0;
17512 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17513 wxEvtHandler *result = 0 ;
17514 void *argp1 = 0 ;
17515 int res1 = 0 ;
17516 PyObject *swig_obj[1] ;
17517
17518 if (!args) SWIG_fail;
17519 swig_obj[0] = args;
17520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17521 if (!SWIG_IsOK(res1)) {
17522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17523 }
17524 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17528 wxPyEndAllowThreads(__tstate);
17529 if (PyErr_Occurred()) SWIG_fail;
17530 }
17531 {
17532 resultobj = wxPyMake_wxObject(result, 0);
17533 }
17534 return resultobj;
17535 fail:
17536 return NULL;
17537 }
17538
17539
17540 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17541 PyObject *resultobj = 0;
17542 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17543 wxEvtHandler *result = 0 ;
17544 void *argp1 = 0 ;
17545 int res1 = 0 ;
17546 PyObject *swig_obj[1] ;
17547
17548 if (!args) SWIG_fail;
17549 swig_obj[0] = args;
17550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17551 if (!SWIG_IsOK(res1)) {
17552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17553 }
17554 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17555 {
17556 PyThreadState* __tstate = wxPyBeginAllowThreads();
17557 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17558 wxPyEndAllowThreads(__tstate);
17559 if (PyErr_Occurred()) SWIG_fail;
17560 }
17561 {
17562 resultobj = wxPyMake_wxObject(result, 0);
17563 }
17564 return resultobj;
17565 fail:
17566 return NULL;
17567 }
17568
17569
17570 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17571 PyObject *resultobj = 0;
17572 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17573 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17574 void *argp1 = 0 ;
17575 int res1 = 0 ;
17576 void *argp2 = 0 ;
17577 int res2 = 0 ;
17578 PyObject * obj0 = 0 ;
17579 PyObject * obj1 = 0 ;
17580 char * kwnames[] = {
17581 (char *) "self",(char *) "handler", NULL
17582 };
17583
17584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17586 if (!SWIG_IsOK(res1)) {
17587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17588 }
17589 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17590 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17591 if (!SWIG_IsOK(res2)) {
17592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17593 }
17594 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17595 {
17596 PyThreadState* __tstate = wxPyBeginAllowThreads();
17597 (arg1)->SetNextHandler(arg2);
17598 wxPyEndAllowThreads(__tstate);
17599 if (PyErr_Occurred()) SWIG_fail;
17600 }
17601 resultobj = SWIG_Py_Void();
17602 return resultobj;
17603 fail:
17604 return NULL;
17605 }
17606
17607
17608 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17609 PyObject *resultobj = 0;
17610 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17611 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17612 void *argp1 = 0 ;
17613 int res1 = 0 ;
17614 void *argp2 = 0 ;
17615 int res2 = 0 ;
17616 PyObject * obj0 = 0 ;
17617 PyObject * obj1 = 0 ;
17618 char * kwnames[] = {
17619 (char *) "self",(char *) "handler", NULL
17620 };
17621
17622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17624 if (!SWIG_IsOK(res1)) {
17625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17626 }
17627 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17628 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17629 if (!SWIG_IsOK(res2)) {
17630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17631 }
17632 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17633 {
17634 PyThreadState* __tstate = wxPyBeginAllowThreads();
17635 (arg1)->SetPreviousHandler(arg2);
17636 wxPyEndAllowThreads(__tstate);
17637 if (PyErr_Occurred()) SWIG_fail;
17638 }
17639 resultobj = SWIG_Py_Void();
17640 return resultobj;
17641 fail:
17642 return NULL;
17643 }
17644
17645
17646 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17647 PyObject *resultobj = 0;
17648 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17649 bool result;
17650 void *argp1 = 0 ;
17651 int res1 = 0 ;
17652 PyObject *swig_obj[1] ;
17653
17654 if (!args) SWIG_fail;
17655 swig_obj[0] = args;
17656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17657 if (!SWIG_IsOK(res1)) {
17658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17659 }
17660 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17661 {
17662 PyThreadState* __tstate = wxPyBeginAllowThreads();
17663 result = (bool)(arg1)->GetEvtHandlerEnabled();
17664 wxPyEndAllowThreads(__tstate);
17665 if (PyErr_Occurred()) SWIG_fail;
17666 }
17667 {
17668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17669 }
17670 return resultobj;
17671 fail:
17672 return NULL;
17673 }
17674
17675
17676 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17677 PyObject *resultobj = 0;
17678 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17679 bool arg2 ;
17680 void *argp1 = 0 ;
17681 int res1 = 0 ;
17682 bool val2 ;
17683 int ecode2 = 0 ;
17684 PyObject * obj0 = 0 ;
17685 PyObject * obj1 = 0 ;
17686 char * kwnames[] = {
17687 (char *) "self",(char *) "enabled", NULL
17688 };
17689
17690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17692 if (!SWIG_IsOK(res1)) {
17693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17694 }
17695 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17696 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17697 if (!SWIG_IsOK(ecode2)) {
17698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17699 }
17700 arg2 = static_cast< bool >(val2);
17701 {
17702 PyThreadState* __tstate = wxPyBeginAllowThreads();
17703 (arg1)->SetEvtHandlerEnabled(arg2);
17704 wxPyEndAllowThreads(__tstate);
17705 if (PyErr_Occurred()) SWIG_fail;
17706 }
17707 resultobj = SWIG_Py_Void();
17708 return resultobj;
17709 fail:
17710 return NULL;
17711 }
17712
17713
17714 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17715 PyObject *resultobj = 0;
17716 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17717 wxEvent *arg2 = 0 ;
17718 bool result;
17719 void *argp1 = 0 ;
17720 int res1 = 0 ;
17721 void *argp2 = 0 ;
17722 int res2 = 0 ;
17723 PyObject * obj0 = 0 ;
17724 PyObject * obj1 = 0 ;
17725 char * kwnames[] = {
17726 (char *) "self",(char *) "event", NULL
17727 };
17728
17729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17731 if (!SWIG_IsOK(res1)) {
17732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17733 }
17734 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17735 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17736 if (!SWIG_IsOK(res2)) {
17737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17738 }
17739 if (!argp2) {
17740 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17741 }
17742 arg2 = reinterpret_cast< wxEvent * >(argp2);
17743 {
17744 PyThreadState* __tstate = wxPyBeginAllowThreads();
17745 result = (bool)(arg1)->ProcessEvent(*arg2);
17746 wxPyEndAllowThreads(__tstate);
17747 if (PyErr_Occurred()) SWIG_fail;
17748 }
17749 {
17750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17751 }
17752 return resultobj;
17753 fail:
17754 return NULL;
17755 }
17756
17757
17758 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17759 PyObject *resultobj = 0;
17760 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17761 wxEvent *arg2 = 0 ;
17762 void *argp1 = 0 ;
17763 int res1 = 0 ;
17764 void *argp2 = 0 ;
17765 int res2 = 0 ;
17766 PyObject * obj0 = 0 ;
17767 PyObject * obj1 = 0 ;
17768 char * kwnames[] = {
17769 (char *) "self",(char *) "event", NULL
17770 };
17771
17772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17774 if (!SWIG_IsOK(res1)) {
17775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17776 }
17777 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17778 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17779 if (!SWIG_IsOK(res2)) {
17780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17781 }
17782 if (!argp2) {
17783 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17784 }
17785 arg2 = reinterpret_cast< wxEvent * >(argp2);
17786 {
17787 PyThreadState* __tstate = wxPyBeginAllowThreads();
17788 (arg1)->AddPendingEvent(*arg2);
17789 wxPyEndAllowThreads(__tstate);
17790 if (PyErr_Occurred()) SWIG_fail;
17791 }
17792 resultobj = SWIG_Py_Void();
17793 return resultobj;
17794 fail:
17795 return NULL;
17796 }
17797
17798
17799 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17800 PyObject *resultobj = 0;
17801 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17802 void *argp1 = 0 ;
17803 int res1 = 0 ;
17804 PyObject *swig_obj[1] ;
17805
17806 if (!args) SWIG_fail;
17807 swig_obj[0] = args;
17808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17809 if (!SWIG_IsOK(res1)) {
17810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17811 }
17812 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17813 {
17814 PyThreadState* __tstate = wxPyBeginAllowThreads();
17815 (arg1)->ProcessPendingEvents();
17816 wxPyEndAllowThreads(__tstate);
17817 if (PyErr_Occurred()) SWIG_fail;
17818 }
17819 resultobj = SWIG_Py_Void();
17820 return resultobj;
17821 fail:
17822 return NULL;
17823 }
17824
17825
17826 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17827 PyObject *resultobj = 0;
17828 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17829 int arg2 ;
17830 int arg3 ;
17831 int arg4 ;
17832 PyObject *arg5 = (PyObject *) 0 ;
17833 void *argp1 = 0 ;
17834 int res1 = 0 ;
17835 int val2 ;
17836 int ecode2 = 0 ;
17837 int val3 ;
17838 int ecode3 = 0 ;
17839 int val4 ;
17840 int ecode4 = 0 ;
17841 PyObject * obj0 = 0 ;
17842 PyObject * obj1 = 0 ;
17843 PyObject * obj2 = 0 ;
17844 PyObject * obj3 = 0 ;
17845 PyObject * obj4 = 0 ;
17846 char * kwnames[] = {
17847 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17848 };
17849
17850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17852 if (!SWIG_IsOK(res1)) {
17853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17854 }
17855 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17856 ecode2 = SWIG_AsVal_int(obj1, &val2);
17857 if (!SWIG_IsOK(ecode2)) {
17858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17859 }
17860 arg2 = static_cast< int >(val2);
17861 ecode3 = SWIG_AsVal_int(obj2, &val3);
17862 if (!SWIG_IsOK(ecode3)) {
17863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17864 }
17865 arg3 = static_cast< int >(val3);
17866 ecode4 = SWIG_AsVal_int(obj3, &val4);
17867 if (!SWIG_IsOK(ecode4)) {
17868 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17869 }
17870 arg4 = static_cast< int >(val4);
17871 arg5 = obj4;
17872 {
17873 PyThreadState* __tstate = wxPyBeginAllowThreads();
17874 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17875 wxPyEndAllowThreads(__tstate);
17876 if (PyErr_Occurred()) SWIG_fail;
17877 }
17878 resultobj = SWIG_Py_Void();
17879 return resultobj;
17880 fail:
17881 return NULL;
17882 }
17883
17884
17885 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17886 PyObject *resultobj = 0;
17887 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17888 int arg2 ;
17889 int arg3 = (int) -1 ;
17890 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17891 bool result;
17892 void *argp1 = 0 ;
17893 int res1 = 0 ;
17894 int val2 ;
17895 int ecode2 = 0 ;
17896 int val3 ;
17897 int ecode3 = 0 ;
17898 int val4 ;
17899 int ecode4 = 0 ;
17900 PyObject * obj0 = 0 ;
17901 PyObject * obj1 = 0 ;
17902 PyObject * obj2 = 0 ;
17903 PyObject * obj3 = 0 ;
17904 char * kwnames[] = {
17905 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17906 };
17907
17908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17910 if (!SWIG_IsOK(res1)) {
17911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17912 }
17913 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17914 ecode2 = SWIG_AsVal_int(obj1, &val2);
17915 if (!SWIG_IsOK(ecode2)) {
17916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17917 }
17918 arg2 = static_cast< int >(val2);
17919 if (obj2) {
17920 ecode3 = SWIG_AsVal_int(obj2, &val3);
17921 if (!SWIG_IsOK(ecode3)) {
17922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17923 }
17924 arg3 = static_cast< int >(val3);
17925 }
17926 if (obj3) {
17927 ecode4 = SWIG_AsVal_int(obj3, &val4);
17928 if (!SWIG_IsOK(ecode4)) {
17929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17930 }
17931 arg4 = static_cast< wxEventType >(val4);
17932 }
17933 {
17934 PyThreadState* __tstate = wxPyBeginAllowThreads();
17935 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
17936 wxPyEndAllowThreads(__tstate);
17937 if (PyErr_Occurred()) SWIG_fail;
17938 }
17939 {
17940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17941 }
17942 return resultobj;
17943 fail:
17944 return NULL;
17945 }
17946
17947
17948 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17949 PyObject *resultobj = 0;
17950 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17951 PyObject *arg2 = (PyObject *) 0 ;
17952 bool arg3 = (bool) true ;
17953 void *argp1 = 0 ;
17954 int res1 = 0 ;
17955 bool val3 ;
17956 int ecode3 = 0 ;
17957 PyObject * obj0 = 0 ;
17958 PyObject * obj1 = 0 ;
17959 PyObject * obj2 = 0 ;
17960 char * kwnames[] = {
17961 (char *) "self",(char *) "_self",(char *) "incref", NULL
17962 };
17963
17964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17966 if (!SWIG_IsOK(res1)) {
17967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17968 }
17969 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17970 arg2 = obj1;
17971 if (obj2) {
17972 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17973 if (!SWIG_IsOK(ecode3)) {
17974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
17975 }
17976 arg3 = static_cast< bool >(val3);
17977 }
17978 {
17979 PyThreadState* __tstate = wxPyBeginAllowThreads();
17980 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
17981 wxPyEndAllowThreads(__tstate);
17982 if (PyErr_Occurred()) SWIG_fail;
17983 }
17984 resultobj = SWIG_Py_Void();
17985 return resultobj;
17986 fail:
17987 return NULL;
17988 }
17989
17990
17991 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17992 PyObject *obj;
17993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17994 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
17995 return SWIG_Py_Void();
17996 }
17997
17998 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17999 return SWIG_Python_InitShadowInstance(args);
18000 }
18001
18002 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18003 PyObject *resultobj = 0;
18004 wxEventType result;
18005
18006 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18007 {
18008 PyThreadState* __tstate = wxPyBeginAllowThreads();
18009 result = (wxEventType)wxNewEventType();
18010 wxPyEndAllowThreads(__tstate);
18011 if (PyErr_Occurred()) SWIG_fail;
18012 }
18013 resultobj = SWIG_From_int(static_cast< int >(result));
18014 return resultobj;
18015 fail:
18016 return NULL;
18017 }
18018
18019
18020 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18021 PyObject *resultobj = 0;
18022 wxEvent *arg1 = (wxEvent *) 0 ;
18023 void *argp1 = 0 ;
18024 int res1 = 0 ;
18025 PyObject *swig_obj[1] ;
18026
18027 if (!args) SWIG_fail;
18028 swig_obj[0] = args;
18029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18030 if (!SWIG_IsOK(res1)) {
18031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18032 }
18033 arg1 = reinterpret_cast< wxEvent * >(argp1);
18034 {
18035 PyThreadState* __tstate = wxPyBeginAllowThreads();
18036 delete arg1;
18037
18038 wxPyEndAllowThreads(__tstate);
18039 if (PyErr_Occurred()) SWIG_fail;
18040 }
18041 resultobj = SWIG_Py_Void();
18042 return resultobj;
18043 fail:
18044 return NULL;
18045 }
18046
18047
18048 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18049 PyObject *resultobj = 0;
18050 wxEvent *arg1 = (wxEvent *) 0 ;
18051 wxEventType arg2 ;
18052 void *argp1 = 0 ;
18053 int res1 = 0 ;
18054 int val2 ;
18055 int ecode2 = 0 ;
18056 PyObject * obj0 = 0 ;
18057 PyObject * obj1 = 0 ;
18058 char * kwnames[] = {
18059 (char *) "self",(char *) "typ", NULL
18060 };
18061
18062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18064 if (!SWIG_IsOK(res1)) {
18065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18066 }
18067 arg1 = reinterpret_cast< wxEvent * >(argp1);
18068 ecode2 = SWIG_AsVal_int(obj1, &val2);
18069 if (!SWIG_IsOK(ecode2)) {
18070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18071 }
18072 arg2 = static_cast< wxEventType >(val2);
18073 {
18074 PyThreadState* __tstate = wxPyBeginAllowThreads();
18075 (arg1)->SetEventType(arg2);
18076 wxPyEndAllowThreads(__tstate);
18077 if (PyErr_Occurred()) SWIG_fail;
18078 }
18079 resultobj = SWIG_Py_Void();
18080 return resultobj;
18081 fail:
18082 return NULL;
18083 }
18084
18085
18086 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18087 PyObject *resultobj = 0;
18088 wxEvent *arg1 = (wxEvent *) 0 ;
18089 wxEventType result;
18090 void *argp1 = 0 ;
18091 int res1 = 0 ;
18092 PyObject *swig_obj[1] ;
18093
18094 if (!args) SWIG_fail;
18095 swig_obj[0] = args;
18096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18097 if (!SWIG_IsOK(res1)) {
18098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18099 }
18100 arg1 = reinterpret_cast< wxEvent * >(argp1);
18101 {
18102 PyThreadState* __tstate = wxPyBeginAllowThreads();
18103 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18104 wxPyEndAllowThreads(__tstate);
18105 if (PyErr_Occurred()) SWIG_fail;
18106 }
18107 resultobj = SWIG_From_int(static_cast< int >(result));
18108 return resultobj;
18109 fail:
18110 return NULL;
18111 }
18112
18113
18114 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18115 PyObject *resultobj = 0;
18116 wxEvent *arg1 = (wxEvent *) 0 ;
18117 wxObject *result = 0 ;
18118 void *argp1 = 0 ;
18119 int res1 = 0 ;
18120 PyObject *swig_obj[1] ;
18121
18122 if (!args) SWIG_fail;
18123 swig_obj[0] = args;
18124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18125 if (!SWIG_IsOK(res1)) {
18126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18127 }
18128 arg1 = reinterpret_cast< wxEvent * >(argp1);
18129 {
18130 PyThreadState* __tstate = wxPyBeginAllowThreads();
18131 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 {
18136 resultobj = wxPyMake_wxObject(result, (bool)0);
18137 }
18138 return resultobj;
18139 fail:
18140 return NULL;
18141 }
18142
18143
18144 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18145 PyObject *resultobj = 0;
18146 wxEvent *arg1 = (wxEvent *) 0 ;
18147 wxObject *arg2 = (wxObject *) 0 ;
18148 void *argp1 = 0 ;
18149 int res1 = 0 ;
18150 void *argp2 = 0 ;
18151 int res2 = 0 ;
18152 PyObject * obj0 = 0 ;
18153 PyObject * obj1 = 0 ;
18154 char * kwnames[] = {
18155 (char *) "self",(char *) "obj", NULL
18156 };
18157
18158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18160 if (!SWIG_IsOK(res1)) {
18161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18162 }
18163 arg1 = reinterpret_cast< wxEvent * >(argp1);
18164 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18165 if (!SWIG_IsOK(res2)) {
18166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18167 }
18168 arg2 = reinterpret_cast< wxObject * >(argp2);
18169 {
18170 PyThreadState* __tstate = wxPyBeginAllowThreads();
18171 (arg1)->SetEventObject(arg2);
18172 wxPyEndAllowThreads(__tstate);
18173 if (PyErr_Occurred()) SWIG_fail;
18174 }
18175 resultobj = SWIG_Py_Void();
18176 return resultobj;
18177 fail:
18178 return NULL;
18179 }
18180
18181
18182 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18183 PyObject *resultobj = 0;
18184 wxEvent *arg1 = (wxEvent *) 0 ;
18185 long result;
18186 void *argp1 = 0 ;
18187 int res1 = 0 ;
18188 PyObject *swig_obj[1] ;
18189
18190 if (!args) SWIG_fail;
18191 swig_obj[0] = args;
18192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18193 if (!SWIG_IsOK(res1)) {
18194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18195 }
18196 arg1 = reinterpret_cast< wxEvent * >(argp1);
18197 {
18198 PyThreadState* __tstate = wxPyBeginAllowThreads();
18199 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18200 wxPyEndAllowThreads(__tstate);
18201 if (PyErr_Occurred()) SWIG_fail;
18202 }
18203 resultobj = SWIG_From_long(static_cast< long >(result));
18204 return resultobj;
18205 fail:
18206 return NULL;
18207 }
18208
18209
18210 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18211 PyObject *resultobj = 0;
18212 wxEvent *arg1 = (wxEvent *) 0 ;
18213 long arg2 = (long) 0 ;
18214 void *argp1 = 0 ;
18215 int res1 = 0 ;
18216 long val2 ;
18217 int ecode2 = 0 ;
18218 PyObject * obj0 = 0 ;
18219 PyObject * obj1 = 0 ;
18220 char * kwnames[] = {
18221 (char *) "self",(char *) "ts", NULL
18222 };
18223
18224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18226 if (!SWIG_IsOK(res1)) {
18227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18228 }
18229 arg1 = reinterpret_cast< wxEvent * >(argp1);
18230 if (obj1) {
18231 ecode2 = SWIG_AsVal_long(obj1, &val2);
18232 if (!SWIG_IsOK(ecode2)) {
18233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18234 }
18235 arg2 = static_cast< long >(val2);
18236 }
18237 {
18238 PyThreadState* __tstate = wxPyBeginAllowThreads();
18239 (arg1)->SetTimestamp(arg2);
18240 wxPyEndAllowThreads(__tstate);
18241 if (PyErr_Occurred()) SWIG_fail;
18242 }
18243 resultobj = SWIG_Py_Void();
18244 return resultobj;
18245 fail:
18246 return NULL;
18247 }
18248
18249
18250 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18251 PyObject *resultobj = 0;
18252 wxEvent *arg1 = (wxEvent *) 0 ;
18253 int result;
18254 void *argp1 = 0 ;
18255 int res1 = 0 ;
18256 PyObject *swig_obj[1] ;
18257
18258 if (!args) SWIG_fail;
18259 swig_obj[0] = args;
18260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18261 if (!SWIG_IsOK(res1)) {
18262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18263 }
18264 arg1 = reinterpret_cast< wxEvent * >(argp1);
18265 {
18266 PyThreadState* __tstate = wxPyBeginAllowThreads();
18267 result = (int)((wxEvent const *)arg1)->GetId();
18268 wxPyEndAllowThreads(__tstate);
18269 if (PyErr_Occurred()) SWIG_fail;
18270 }
18271 resultobj = SWIG_From_int(static_cast< int >(result));
18272 return resultobj;
18273 fail:
18274 return NULL;
18275 }
18276
18277
18278 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18279 PyObject *resultobj = 0;
18280 wxEvent *arg1 = (wxEvent *) 0 ;
18281 int arg2 ;
18282 void *argp1 = 0 ;
18283 int res1 = 0 ;
18284 int val2 ;
18285 int ecode2 = 0 ;
18286 PyObject * obj0 = 0 ;
18287 PyObject * obj1 = 0 ;
18288 char * kwnames[] = {
18289 (char *) "self",(char *) "Id", NULL
18290 };
18291
18292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18294 if (!SWIG_IsOK(res1)) {
18295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18296 }
18297 arg1 = reinterpret_cast< wxEvent * >(argp1);
18298 ecode2 = SWIG_AsVal_int(obj1, &val2);
18299 if (!SWIG_IsOK(ecode2)) {
18300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18301 }
18302 arg2 = static_cast< int >(val2);
18303 {
18304 PyThreadState* __tstate = wxPyBeginAllowThreads();
18305 (arg1)->SetId(arg2);
18306 wxPyEndAllowThreads(__tstate);
18307 if (PyErr_Occurred()) SWIG_fail;
18308 }
18309 resultobj = SWIG_Py_Void();
18310 return resultobj;
18311 fail:
18312 return NULL;
18313 }
18314
18315
18316 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18317 PyObject *resultobj = 0;
18318 wxEvent *arg1 = (wxEvent *) 0 ;
18319 bool result;
18320 void *argp1 = 0 ;
18321 int res1 = 0 ;
18322 PyObject *swig_obj[1] ;
18323
18324 if (!args) SWIG_fail;
18325 swig_obj[0] = args;
18326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18327 if (!SWIG_IsOK(res1)) {
18328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18329 }
18330 arg1 = reinterpret_cast< wxEvent * >(argp1);
18331 {
18332 PyThreadState* __tstate = wxPyBeginAllowThreads();
18333 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18334 wxPyEndAllowThreads(__tstate);
18335 if (PyErr_Occurred()) SWIG_fail;
18336 }
18337 {
18338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18339 }
18340 return resultobj;
18341 fail:
18342 return NULL;
18343 }
18344
18345
18346 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18347 PyObject *resultobj = 0;
18348 wxEvent *arg1 = (wxEvent *) 0 ;
18349 bool arg2 = (bool) true ;
18350 void *argp1 = 0 ;
18351 int res1 = 0 ;
18352 bool val2 ;
18353 int ecode2 = 0 ;
18354 PyObject * obj0 = 0 ;
18355 PyObject * obj1 = 0 ;
18356 char * kwnames[] = {
18357 (char *) "self",(char *) "skip", NULL
18358 };
18359
18360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18362 if (!SWIG_IsOK(res1)) {
18363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18364 }
18365 arg1 = reinterpret_cast< wxEvent * >(argp1);
18366 if (obj1) {
18367 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18368 if (!SWIG_IsOK(ecode2)) {
18369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18370 }
18371 arg2 = static_cast< bool >(val2);
18372 }
18373 {
18374 PyThreadState* __tstate = wxPyBeginAllowThreads();
18375 (arg1)->Skip(arg2);
18376 wxPyEndAllowThreads(__tstate);
18377 if (PyErr_Occurred()) SWIG_fail;
18378 }
18379 resultobj = SWIG_Py_Void();
18380 return resultobj;
18381 fail:
18382 return NULL;
18383 }
18384
18385
18386 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18387 PyObject *resultobj = 0;
18388 wxEvent *arg1 = (wxEvent *) 0 ;
18389 bool result;
18390 void *argp1 = 0 ;
18391 int res1 = 0 ;
18392 PyObject *swig_obj[1] ;
18393
18394 if (!args) SWIG_fail;
18395 swig_obj[0] = args;
18396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18397 if (!SWIG_IsOK(res1)) {
18398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18399 }
18400 arg1 = reinterpret_cast< wxEvent * >(argp1);
18401 {
18402 PyThreadState* __tstate = wxPyBeginAllowThreads();
18403 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18404 wxPyEndAllowThreads(__tstate);
18405 if (PyErr_Occurred()) SWIG_fail;
18406 }
18407 {
18408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18409 }
18410 return resultobj;
18411 fail:
18412 return NULL;
18413 }
18414
18415
18416 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18417 PyObject *resultobj = 0;
18418 wxEvent *arg1 = (wxEvent *) 0 ;
18419 bool result;
18420 void *argp1 = 0 ;
18421 int res1 = 0 ;
18422 PyObject *swig_obj[1] ;
18423
18424 if (!args) SWIG_fail;
18425 swig_obj[0] = args;
18426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18427 if (!SWIG_IsOK(res1)) {
18428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18429 }
18430 arg1 = reinterpret_cast< wxEvent * >(argp1);
18431 {
18432 PyThreadState* __tstate = wxPyBeginAllowThreads();
18433 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18434 wxPyEndAllowThreads(__tstate);
18435 if (PyErr_Occurred()) SWIG_fail;
18436 }
18437 {
18438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18439 }
18440 return resultobj;
18441 fail:
18442 return NULL;
18443 }
18444
18445
18446 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18447 PyObject *resultobj = 0;
18448 wxEvent *arg1 = (wxEvent *) 0 ;
18449 int result;
18450 void *argp1 = 0 ;
18451 int res1 = 0 ;
18452 PyObject *swig_obj[1] ;
18453
18454 if (!args) SWIG_fail;
18455 swig_obj[0] = args;
18456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18457 if (!SWIG_IsOK(res1)) {
18458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18459 }
18460 arg1 = reinterpret_cast< wxEvent * >(argp1);
18461 {
18462 PyThreadState* __tstate = wxPyBeginAllowThreads();
18463 result = (int)(arg1)->StopPropagation();
18464 wxPyEndAllowThreads(__tstate);
18465 if (PyErr_Occurred()) SWIG_fail;
18466 }
18467 resultobj = SWIG_From_int(static_cast< int >(result));
18468 return resultobj;
18469 fail:
18470 return NULL;
18471 }
18472
18473
18474 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18475 PyObject *resultobj = 0;
18476 wxEvent *arg1 = (wxEvent *) 0 ;
18477 int arg2 ;
18478 void *argp1 = 0 ;
18479 int res1 = 0 ;
18480 int val2 ;
18481 int ecode2 = 0 ;
18482 PyObject * obj0 = 0 ;
18483 PyObject * obj1 = 0 ;
18484 char * kwnames[] = {
18485 (char *) "self",(char *) "propagationLevel", NULL
18486 };
18487
18488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18490 if (!SWIG_IsOK(res1)) {
18491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18492 }
18493 arg1 = reinterpret_cast< wxEvent * >(argp1);
18494 ecode2 = SWIG_AsVal_int(obj1, &val2);
18495 if (!SWIG_IsOK(ecode2)) {
18496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18497 }
18498 arg2 = static_cast< int >(val2);
18499 {
18500 PyThreadState* __tstate = wxPyBeginAllowThreads();
18501 (arg1)->ResumePropagation(arg2);
18502 wxPyEndAllowThreads(__tstate);
18503 if (PyErr_Occurred()) SWIG_fail;
18504 }
18505 resultobj = SWIG_Py_Void();
18506 return resultobj;
18507 fail:
18508 return NULL;
18509 }
18510
18511
18512 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18513 PyObject *resultobj = 0;
18514 wxEvent *arg1 = (wxEvent *) 0 ;
18515 wxEvent *result = 0 ;
18516 void *argp1 = 0 ;
18517 int res1 = 0 ;
18518 PyObject *swig_obj[1] ;
18519
18520 if (!args) SWIG_fail;
18521 swig_obj[0] = args;
18522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18523 if (!SWIG_IsOK(res1)) {
18524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18525 }
18526 arg1 = reinterpret_cast< wxEvent * >(argp1);
18527 {
18528 PyThreadState* __tstate = wxPyBeginAllowThreads();
18529 result = (wxEvent *)(arg1)->Clone();
18530 wxPyEndAllowThreads(__tstate);
18531 if (PyErr_Occurred()) SWIG_fail;
18532 }
18533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18534 return resultobj;
18535 fail:
18536 return NULL;
18537 }
18538
18539
18540 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18541 PyObject *obj;
18542 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18543 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18544 return SWIG_Py_Void();
18545 }
18546
18547 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18548 PyObject *resultobj = 0;
18549 wxEvent *arg1 = 0 ;
18550 wxPropagationDisabler *result = 0 ;
18551 void *argp1 = 0 ;
18552 int res1 = 0 ;
18553 PyObject * obj0 = 0 ;
18554 char * kwnames[] = {
18555 (char *) "event", NULL
18556 };
18557
18558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18559 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18560 if (!SWIG_IsOK(res1)) {
18561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18562 }
18563 if (!argp1) {
18564 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18565 }
18566 arg1 = reinterpret_cast< wxEvent * >(argp1);
18567 {
18568 PyThreadState* __tstate = wxPyBeginAllowThreads();
18569 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18570 wxPyEndAllowThreads(__tstate);
18571 if (PyErr_Occurred()) SWIG_fail;
18572 }
18573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18574 return resultobj;
18575 fail:
18576 return NULL;
18577 }
18578
18579
18580 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18581 PyObject *resultobj = 0;
18582 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18583 void *argp1 = 0 ;
18584 int res1 = 0 ;
18585 PyObject *swig_obj[1] ;
18586
18587 if (!args) SWIG_fail;
18588 swig_obj[0] = args;
18589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18590 if (!SWIG_IsOK(res1)) {
18591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18592 }
18593 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 delete arg1;
18597
18598 wxPyEndAllowThreads(__tstate);
18599 if (PyErr_Occurred()) SWIG_fail;
18600 }
18601 resultobj = SWIG_Py_Void();
18602 return resultobj;
18603 fail:
18604 return NULL;
18605 }
18606
18607
18608 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18609 PyObject *obj;
18610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18611 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18612 return SWIG_Py_Void();
18613 }
18614
18615 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18616 return SWIG_Python_InitShadowInstance(args);
18617 }
18618
18619 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18620 PyObject *resultobj = 0;
18621 wxEvent *arg1 = 0 ;
18622 wxPropagateOnce *result = 0 ;
18623 void *argp1 = 0 ;
18624 int res1 = 0 ;
18625 PyObject * obj0 = 0 ;
18626 char * kwnames[] = {
18627 (char *) "event", NULL
18628 };
18629
18630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18631 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18632 if (!SWIG_IsOK(res1)) {
18633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18634 }
18635 if (!argp1) {
18636 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18637 }
18638 arg1 = reinterpret_cast< wxEvent * >(argp1);
18639 {
18640 PyThreadState* __tstate = wxPyBeginAllowThreads();
18641 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18642 wxPyEndAllowThreads(__tstate);
18643 if (PyErr_Occurred()) SWIG_fail;
18644 }
18645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18646 return resultobj;
18647 fail:
18648 return NULL;
18649 }
18650
18651
18652 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18653 PyObject *resultobj = 0;
18654 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18655 void *argp1 = 0 ;
18656 int res1 = 0 ;
18657 PyObject *swig_obj[1] ;
18658
18659 if (!args) SWIG_fail;
18660 swig_obj[0] = args;
18661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18662 if (!SWIG_IsOK(res1)) {
18663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18664 }
18665 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18666 {
18667 PyThreadState* __tstate = wxPyBeginAllowThreads();
18668 delete arg1;
18669
18670 wxPyEndAllowThreads(__tstate);
18671 if (PyErr_Occurred()) SWIG_fail;
18672 }
18673 resultobj = SWIG_Py_Void();
18674 return resultobj;
18675 fail:
18676 return NULL;
18677 }
18678
18679
18680 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18681 PyObject *obj;
18682 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18683 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18684 return SWIG_Py_Void();
18685 }
18686
18687 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18688 return SWIG_Python_InitShadowInstance(args);
18689 }
18690
18691 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18692 PyObject *resultobj = 0;
18693 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18694 int arg2 = (int) 0 ;
18695 wxCommandEvent *result = 0 ;
18696 int val1 ;
18697 int ecode1 = 0 ;
18698 int val2 ;
18699 int ecode2 = 0 ;
18700 PyObject * obj0 = 0 ;
18701 PyObject * obj1 = 0 ;
18702 char * kwnames[] = {
18703 (char *) "commandType",(char *) "winid", NULL
18704 };
18705
18706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18707 if (obj0) {
18708 ecode1 = SWIG_AsVal_int(obj0, &val1);
18709 if (!SWIG_IsOK(ecode1)) {
18710 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18711 }
18712 arg1 = static_cast< wxEventType >(val1);
18713 }
18714 if (obj1) {
18715 ecode2 = SWIG_AsVal_int(obj1, &val2);
18716 if (!SWIG_IsOK(ecode2)) {
18717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18718 }
18719 arg2 = static_cast< int >(val2);
18720 }
18721 {
18722 PyThreadState* __tstate = wxPyBeginAllowThreads();
18723 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18724 wxPyEndAllowThreads(__tstate);
18725 if (PyErr_Occurred()) SWIG_fail;
18726 }
18727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18728 return resultobj;
18729 fail:
18730 return NULL;
18731 }
18732
18733
18734 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18735 PyObject *resultobj = 0;
18736 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18737 int result;
18738 void *argp1 = 0 ;
18739 int res1 = 0 ;
18740 PyObject *swig_obj[1] ;
18741
18742 if (!args) SWIG_fail;
18743 swig_obj[0] = args;
18744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18745 if (!SWIG_IsOK(res1)) {
18746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18747 }
18748 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18749 {
18750 PyThreadState* __tstate = wxPyBeginAllowThreads();
18751 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18752 wxPyEndAllowThreads(__tstate);
18753 if (PyErr_Occurred()) SWIG_fail;
18754 }
18755 resultobj = SWIG_From_int(static_cast< int >(result));
18756 return resultobj;
18757 fail:
18758 return NULL;
18759 }
18760
18761
18762 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18763 PyObject *resultobj = 0;
18764 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18765 wxString *arg2 = 0 ;
18766 void *argp1 = 0 ;
18767 int res1 = 0 ;
18768 bool temp2 = false ;
18769 PyObject * obj0 = 0 ;
18770 PyObject * obj1 = 0 ;
18771 char * kwnames[] = {
18772 (char *) "self",(char *) "s", NULL
18773 };
18774
18775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18777 if (!SWIG_IsOK(res1)) {
18778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18779 }
18780 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18781 {
18782 arg2 = wxString_in_helper(obj1);
18783 if (arg2 == NULL) SWIG_fail;
18784 temp2 = true;
18785 }
18786 {
18787 PyThreadState* __tstate = wxPyBeginAllowThreads();
18788 (arg1)->SetString((wxString const &)*arg2);
18789 wxPyEndAllowThreads(__tstate);
18790 if (PyErr_Occurred()) SWIG_fail;
18791 }
18792 resultobj = SWIG_Py_Void();
18793 {
18794 if (temp2)
18795 delete arg2;
18796 }
18797 return resultobj;
18798 fail:
18799 {
18800 if (temp2)
18801 delete arg2;
18802 }
18803 return NULL;
18804 }
18805
18806
18807 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18808 PyObject *resultobj = 0;
18809 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18810 wxString result;
18811 void *argp1 = 0 ;
18812 int res1 = 0 ;
18813 PyObject *swig_obj[1] ;
18814
18815 if (!args) SWIG_fail;
18816 swig_obj[0] = args;
18817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18818 if (!SWIG_IsOK(res1)) {
18819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18820 }
18821 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18822 {
18823 PyThreadState* __tstate = wxPyBeginAllowThreads();
18824 result = ((wxCommandEvent const *)arg1)->GetString();
18825 wxPyEndAllowThreads(__tstate);
18826 if (PyErr_Occurred()) SWIG_fail;
18827 }
18828 {
18829 #if wxUSE_UNICODE
18830 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18831 #else
18832 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18833 #endif
18834 }
18835 return resultobj;
18836 fail:
18837 return NULL;
18838 }
18839
18840
18841 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18842 PyObject *resultobj = 0;
18843 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18844 bool result;
18845 void *argp1 = 0 ;
18846 int res1 = 0 ;
18847 PyObject *swig_obj[1] ;
18848
18849 if (!args) SWIG_fail;
18850 swig_obj[0] = args;
18851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18852 if (!SWIG_IsOK(res1)) {
18853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18854 }
18855 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18856 {
18857 PyThreadState* __tstate = wxPyBeginAllowThreads();
18858 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18859 wxPyEndAllowThreads(__tstate);
18860 if (PyErr_Occurred()) SWIG_fail;
18861 }
18862 {
18863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18864 }
18865 return resultobj;
18866 fail:
18867 return NULL;
18868 }
18869
18870
18871 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18872 PyObject *resultobj = 0;
18873 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18874 bool result;
18875 void *argp1 = 0 ;
18876 int res1 = 0 ;
18877 PyObject *swig_obj[1] ;
18878
18879 if (!args) SWIG_fail;
18880 swig_obj[0] = args;
18881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18882 if (!SWIG_IsOK(res1)) {
18883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18884 }
18885 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18886 {
18887 PyThreadState* __tstate = wxPyBeginAllowThreads();
18888 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18889 wxPyEndAllowThreads(__tstate);
18890 if (PyErr_Occurred()) SWIG_fail;
18891 }
18892 {
18893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18894 }
18895 return resultobj;
18896 fail:
18897 return NULL;
18898 }
18899
18900
18901 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18902 PyObject *resultobj = 0;
18903 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18904 long arg2 ;
18905 void *argp1 = 0 ;
18906 int res1 = 0 ;
18907 long val2 ;
18908 int ecode2 = 0 ;
18909 PyObject * obj0 = 0 ;
18910 PyObject * obj1 = 0 ;
18911 char * kwnames[] = {
18912 (char *) "self",(char *) "extraLong", NULL
18913 };
18914
18915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18917 if (!SWIG_IsOK(res1)) {
18918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18919 }
18920 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18921 ecode2 = SWIG_AsVal_long(obj1, &val2);
18922 if (!SWIG_IsOK(ecode2)) {
18923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18924 }
18925 arg2 = static_cast< long >(val2);
18926 {
18927 PyThreadState* __tstate = wxPyBeginAllowThreads();
18928 (arg1)->SetExtraLong(arg2);
18929 wxPyEndAllowThreads(__tstate);
18930 if (PyErr_Occurred()) SWIG_fail;
18931 }
18932 resultobj = SWIG_Py_Void();
18933 return resultobj;
18934 fail:
18935 return NULL;
18936 }
18937
18938
18939 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18940 PyObject *resultobj = 0;
18941 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18942 long result;
18943 void *argp1 = 0 ;
18944 int res1 = 0 ;
18945 PyObject *swig_obj[1] ;
18946
18947 if (!args) SWIG_fail;
18948 swig_obj[0] = args;
18949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18950 if (!SWIG_IsOK(res1)) {
18951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18952 }
18953 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18954 {
18955 PyThreadState* __tstate = wxPyBeginAllowThreads();
18956 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
18957 wxPyEndAllowThreads(__tstate);
18958 if (PyErr_Occurred()) SWIG_fail;
18959 }
18960 resultobj = SWIG_From_long(static_cast< long >(result));
18961 return resultobj;
18962 fail:
18963 return NULL;
18964 }
18965
18966
18967 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18968 PyObject *resultobj = 0;
18969 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18970 int arg2 ;
18971 void *argp1 = 0 ;
18972 int res1 = 0 ;
18973 int val2 ;
18974 int ecode2 = 0 ;
18975 PyObject * obj0 = 0 ;
18976 PyObject * obj1 = 0 ;
18977 char * kwnames[] = {
18978 (char *) "self",(char *) "i", NULL
18979 };
18980
18981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
18982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18983 if (!SWIG_IsOK(res1)) {
18984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18985 }
18986 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18987 ecode2 = SWIG_AsVal_int(obj1, &val2);
18988 if (!SWIG_IsOK(ecode2)) {
18989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
18990 }
18991 arg2 = static_cast< int >(val2);
18992 {
18993 PyThreadState* __tstate = wxPyBeginAllowThreads();
18994 (arg1)->SetInt(arg2);
18995 wxPyEndAllowThreads(__tstate);
18996 if (PyErr_Occurred()) SWIG_fail;
18997 }
18998 resultobj = SWIG_Py_Void();
18999 return resultobj;
19000 fail:
19001 return NULL;
19002 }
19003
19004
19005 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19006 PyObject *resultobj = 0;
19007 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19008 long result;
19009 void *argp1 = 0 ;
19010 int res1 = 0 ;
19011 PyObject *swig_obj[1] ;
19012
19013 if (!args) SWIG_fail;
19014 swig_obj[0] = args;
19015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19016 if (!SWIG_IsOK(res1)) {
19017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19018 }
19019 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19020 {
19021 PyThreadState* __tstate = wxPyBeginAllowThreads();
19022 result = (long)((wxCommandEvent const *)arg1)->GetInt();
19023 wxPyEndAllowThreads(__tstate);
19024 if (PyErr_Occurred()) SWIG_fail;
19025 }
19026 resultobj = SWIG_From_long(static_cast< long >(result));
19027 return resultobj;
19028 fail:
19029 return NULL;
19030 }
19031
19032
19033 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19034 PyObject *resultobj = 0;
19035 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19036 PyObject *result = 0 ;
19037 void *argp1 = 0 ;
19038 int res1 = 0 ;
19039 PyObject *swig_obj[1] ;
19040
19041 if (!args) SWIG_fail;
19042 swig_obj[0] = args;
19043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19044 if (!SWIG_IsOK(res1)) {
19045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19046 }
19047 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19048 {
19049 PyThreadState* __tstate = wxPyBeginAllowThreads();
19050 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19051 wxPyEndAllowThreads(__tstate);
19052 if (PyErr_Occurred()) SWIG_fail;
19053 }
19054 resultobj = result;
19055 return resultobj;
19056 fail:
19057 return NULL;
19058 }
19059
19060
19061 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19062 PyObject *resultobj = 0;
19063 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19064 PyObject *arg2 = (PyObject *) 0 ;
19065 void *argp1 = 0 ;
19066 int res1 = 0 ;
19067 PyObject * obj0 = 0 ;
19068 PyObject * obj1 = 0 ;
19069 char * kwnames[] = {
19070 (char *) "self",(char *) "clientData", NULL
19071 };
19072
19073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19075 if (!SWIG_IsOK(res1)) {
19076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19077 }
19078 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19079 arg2 = obj1;
19080 {
19081 PyThreadState* __tstate = wxPyBeginAllowThreads();
19082 wxCommandEvent_SetClientData(arg1,arg2);
19083 wxPyEndAllowThreads(__tstate);
19084 if (PyErr_Occurred()) SWIG_fail;
19085 }
19086 resultobj = SWIG_Py_Void();
19087 return resultobj;
19088 fail:
19089 return NULL;
19090 }
19091
19092
19093 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19094 PyObject *resultobj = 0;
19095 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19096 wxEvent *result = 0 ;
19097 void *argp1 = 0 ;
19098 int res1 = 0 ;
19099 PyObject *swig_obj[1] ;
19100
19101 if (!args) SWIG_fail;
19102 swig_obj[0] = args;
19103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19104 if (!SWIG_IsOK(res1)) {
19105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19106 }
19107 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19108 {
19109 PyThreadState* __tstate = wxPyBeginAllowThreads();
19110 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19111 wxPyEndAllowThreads(__tstate);
19112 if (PyErr_Occurred()) SWIG_fail;
19113 }
19114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19115 return resultobj;
19116 fail:
19117 return NULL;
19118 }
19119
19120
19121 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19122 PyObject *obj;
19123 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19124 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19125 return SWIG_Py_Void();
19126 }
19127
19128 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19129 return SWIG_Python_InitShadowInstance(args);
19130 }
19131
19132 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19133 PyObject *resultobj = 0;
19134 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19135 int arg2 = (int) 0 ;
19136 wxNotifyEvent *result = 0 ;
19137 int val1 ;
19138 int ecode1 = 0 ;
19139 int val2 ;
19140 int ecode2 = 0 ;
19141 PyObject * obj0 = 0 ;
19142 PyObject * obj1 = 0 ;
19143 char * kwnames[] = {
19144 (char *) "commandType",(char *) "winid", NULL
19145 };
19146
19147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19148 if (obj0) {
19149 ecode1 = SWIG_AsVal_int(obj0, &val1);
19150 if (!SWIG_IsOK(ecode1)) {
19151 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19152 }
19153 arg1 = static_cast< wxEventType >(val1);
19154 }
19155 if (obj1) {
19156 ecode2 = SWIG_AsVal_int(obj1, &val2);
19157 if (!SWIG_IsOK(ecode2)) {
19158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19159 }
19160 arg2 = static_cast< int >(val2);
19161 }
19162 {
19163 PyThreadState* __tstate = wxPyBeginAllowThreads();
19164 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19165 wxPyEndAllowThreads(__tstate);
19166 if (PyErr_Occurred()) SWIG_fail;
19167 }
19168 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19169 return resultobj;
19170 fail:
19171 return NULL;
19172 }
19173
19174
19175 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19176 PyObject *resultobj = 0;
19177 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19178 void *argp1 = 0 ;
19179 int res1 = 0 ;
19180 PyObject *swig_obj[1] ;
19181
19182 if (!args) SWIG_fail;
19183 swig_obj[0] = args;
19184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19185 if (!SWIG_IsOK(res1)) {
19186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19187 }
19188 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19189 {
19190 PyThreadState* __tstate = wxPyBeginAllowThreads();
19191 (arg1)->Veto();
19192 wxPyEndAllowThreads(__tstate);
19193 if (PyErr_Occurred()) SWIG_fail;
19194 }
19195 resultobj = SWIG_Py_Void();
19196 return resultobj;
19197 fail:
19198 return NULL;
19199 }
19200
19201
19202 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19203 PyObject *resultobj = 0;
19204 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19205 void *argp1 = 0 ;
19206 int res1 = 0 ;
19207 PyObject *swig_obj[1] ;
19208
19209 if (!args) SWIG_fail;
19210 swig_obj[0] = args;
19211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19212 if (!SWIG_IsOK(res1)) {
19213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19214 }
19215 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19216 {
19217 PyThreadState* __tstate = wxPyBeginAllowThreads();
19218 (arg1)->Allow();
19219 wxPyEndAllowThreads(__tstate);
19220 if (PyErr_Occurred()) SWIG_fail;
19221 }
19222 resultobj = SWIG_Py_Void();
19223 return resultobj;
19224 fail:
19225 return NULL;
19226 }
19227
19228
19229 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19230 PyObject *resultobj = 0;
19231 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19232 bool result;
19233 void *argp1 = 0 ;
19234 int res1 = 0 ;
19235 PyObject *swig_obj[1] ;
19236
19237 if (!args) SWIG_fail;
19238 swig_obj[0] = args;
19239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19240 if (!SWIG_IsOK(res1)) {
19241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19242 }
19243 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19244 {
19245 PyThreadState* __tstate = wxPyBeginAllowThreads();
19246 result = (bool)(arg1)->IsAllowed();
19247 wxPyEndAllowThreads(__tstate);
19248 if (PyErr_Occurred()) SWIG_fail;
19249 }
19250 {
19251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19252 }
19253 return resultobj;
19254 fail:
19255 return NULL;
19256 }
19257
19258
19259 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19260 PyObject *obj;
19261 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19262 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19263 return SWIG_Py_Void();
19264 }
19265
19266 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19267 return SWIG_Python_InitShadowInstance(args);
19268 }
19269
19270 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19271 PyObject *resultobj = 0;
19272 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19273 int arg2 = (int) 0 ;
19274 int arg3 = (int) 0 ;
19275 int arg4 = (int) 0 ;
19276 wxScrollEvent *result = 0 ;
19277 int val1 ;
19278 int ecode1 = 0 ;
19279 int val2 ;
19280 int ecode2 = 0 ;
19281 int val3 ;
19282 int ecode3 = 0 ;
19283 int val4 ;
19284 int ecode4 = 0 ;
19285 PyObject * obj0 = 0 ;
19286 PyObject * obj1 = 0 ;
19287 PyObject * obj2 = 0 ;
19288 PyObject * obj3 = 0 ;
19289 char * kwnames[] = {
19290 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19291 };
19292
19293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19294 if (obj0) {
19295 ecode1 = SWIG_AsVal_int(obj0, &val1);
19296 if (!SWIG_IsOK(ecode1)) {
19297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19298 }
19299 arg1 = static_cast< wxEventType >(val1);
19300 }
19301 if (obj1) {
19302 ecode2 = SWIG_AsVal_int(obj1, &val2);
19303 if (!SWIG_IsOK(ecode2)) {
19304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19305 }
19306 arg2 = static_cast< int >(val2);
19307 }
19308 if (obj2) {
19309 ecode3 = SWIG_AsVal_int(obj2, &val3);
19310 if (!SWIG_IsOK(ecode3)) {
19311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19312 }
19313 arg3 = static_cast< int >(val3);
19314 }
19315 if (obj3) {
19316 ecode4 = SWIG_AsVal_int(obj3, &val4);
19317 if (!SWIG_IsOK(ecode4)) {
19318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19319 }
19320 arg4 = static_cast< int >(val4);
19321 }
19322 {
19323 PyThreadState* __tstate = wxPyBeginAllowThreads();
19324 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19325 wxPyEndAllowThreads(__tstate);
19326 if (PyErr_Occurred()) SWIG_fail;
19327 }
19328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19329 return resultobj;
19330 fail:
19331 return NULL;
19332 }
19333
19334
19335 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19336 PyObject *resultobj = 0;
19337 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19338 int result;
19339 void *argp1 = 0 ;
19340 int res1 = 0 ;
19341 PyObject *swig_obj[1] ;
19342
19343 if (!args) SWIG_fail;
19344 swig_obj[0] = args;
19345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19346 if (!SWIG_IsOK(res1)) {
19347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19348 }
19349 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19350 {
19351 PyThreadState* __tstate = wxPyBeginAllowThreads();
19352 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19353 wxPyEndAllowThreads(__tstate);
19354 if (PyErr_Occurred()) SWIG_fail;
19355 }
19356 resultobj = SWIG_From_int(static_cast< int >(result));
19357 return resultobj;
19358 fail:
19359 return NULL;
19360 }
19361
19362
19363 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19364 PyObject *resultobj = 0;
19365 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19366 int result;
19367 void *argp1 = 0 ;
19368 int res1 = 0 ;
19369 PyObject *swig_obj[1] ;
19370
19371 if (!args) SWIG_fail;
19372 swig_obj[0] = args;
19373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19374 if (!SWIG_IsOK(res1)) {
19375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19376 }
19377 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19378 {
19379 PyThreadState* __tstate = wxPyBeginAllowThreads();
19380 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19381 wxPyEndAllowThreads(__tstate);
19382 if (PyErr_Occurred()) SWIG_fail;
19383 }
19384 resultobj = SWIG_From_int(static_cast< int >(result));
19385 return resultobj;
19386 fail:
19387 return NULL;
19388 }
19389
19390
19391 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19392 PyObject *resultobj = 0;
19393 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19394 int arg2 ;
19395 void *argp1 = 0 ;
19396 int res1 = 0 ;
19397 int val2 ;
19398 int ecode2 = 0 ;
19399 PyObject * obj0 = 0 ;
19400 PyObject * obj1 = 0 ;
19401 char * kwnames[] = {
19402 (char *) "self",(char *) "orient", NULL
19403 };
19404
19405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19407 if (!SWIG_IsOK(res1)) {
19408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19409 }
19410 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19411 ecode2 = SWIG_AsVal_int(obj1, &val2);
19412 if (!SWIG_IsOK(ecode2)) {
19413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19414 }
19415 arg2 = static_cast< int >(val2);
19416 {
19417 PyThreadState* __tstate = wxPyBeginAllowThreads();
19418 (arg1)->SetOrientation(arg2);
19419 wxPyEndAllowThreads(__tstate);
19420 if (PyErr_Occurred()) SWIG_fail;
19421 }
19422 resultobj = SWIG_Py_Void();
19423 return resultobj;
19424 fail:
19425 return NULL;
19426 }
19427
19428
19429 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19430 PyObject *resultobj = 0;
19431 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19432 int arg2 ;
19433 void *argp1 = 0 ;
19434 int res1 = 0 ;
19435 int val2 ;
19436 int ecode2 = 0 ;
19437 PyObject * obj0 = 0 ;
19438 PyObject * obj1 = 0 ;
19439 char * kwnames[] = {
19440 (char *) "self",(char *) "pos", NULL
19441 };
19442
19443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19445 if (!SWIG_IsOK(res1)) {
19446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19447 }
19448 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19449 ecode2 = SWIG_AsVal_int(obj1, &val2);
19450 if (!SWIG_IsOK(ecode2)) {
19451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19452 }
19453 arg2 = static_cast< int >(val2);
19454 {
19455 PyThreadState* __tstate = wxPyBeginAllowThreads();
19456 (arg1)->SetPosition(arg2);
19457 wxPyEndAllowThreads(__tstate);
19458 if (PyErr_Occurred()) SWIG_fail;
19459 }
19460 resultobj = SWIG_Py_Void();
19461 return resultobj;
19462 fail:
19463 return NULL;
19464 }
19465
19466
19467 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19468 PyObject *obj;
19469 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19470 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19471 return SWIG_Py_Void();
19472 }
19473
19474 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19475 return SWIG_Python_InitShadowInstance(args);
19476 }
19477
19478 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19479 PyObject *resultobj = 0;
19480 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19481 int arg2 = (int) 0 ;
19482 int arg3 = (int) 0 ;
19483 wxScrollWinEvent *result = 0 ;
19484 int val1 ;
19485 int ecode1 = 0 ;
19486 int val2 ;
19487 int ecode2 = 0 ;
19488 int val3 ;
19489 int ecode3 = 0 ;
19490 PyObject * obj0 = 0 ;
19491 PyObject * obj1 = 0 ;
19492 PyObject * obj2 = 0 ;
19493 char * kwnames[] = {
19494 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19495 };
19496
19497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19498 if (obj0) {
19499 ecode1 = SWIG_AsVal_int(obj0, &val1);
19500 if (!SWIG_IsOK(ecode1)) {
19501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19502 }
19503 arg1 = static_cast< wxEventType >(val1);
19504 }
19505 if (obj1) {
19506 ecode2 = SWIG_AsVal_int(obj1, &val2);
19507 if (!SWIG_IsOK(ecode2)) {
19508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19509 }
19510 arg2 = static_cast< int >(val2);
19511 }
19512 if (obj2) {
19513 ecode3 = SWIG_AsVal_int(obj2, &val3);
19514 if (!SWIG_IsOK(ecode3)) {
19515 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19516 }
19517 arg3 = static_cast< int >(val3);
19518 }
19519 {
19520 PyThreadState* __tstate = wxPyBeginAllowThreads();
19521 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19522 wxPyEndAllowThreads(__tstate);
19523 if (PyErr_Occurred()) SWIG_fail;
19524 }
19525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19526 return resultobj;
19527 fail:
19528 return NULL;
19529 }
19530
19531
19532 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19533 PyObject *resultobj = 0;
19534 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19535 int result;
19536 void *argp1 = 0 ;
19537 int res1 = 0 ;
19538 PyObject *swig_obj[1] ;
19539
19540 if (!args) SWIG_fail;
19541 swig_obj[0] = args;
19542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19543 if (!SWIG_IsOK(res1)) {
19544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19545 }
19546 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19547 {
19548 PyThreadState* __tstate = wxPyBeginAllowThreads();
19549 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 resultobj = SWIG_From_int(static_cast< int >(result));
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19561 PyObject *resultobj = 0;
19562 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19563 int result;
19564 void *argp1 = 0 ;
19565 int res1 = 0 ;
19566 PyObject *swig_obj[1] ;
19567
19568 if (!args) SWIG_fail;
19569 swig_obj[0] = args;
19570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19571 if (!SWIG_IsOK(res1)) {
19572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19573 }
19574 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19575 {
19576 PyThreadState* __tstate = wxPyBeginAllowThreads();
19577 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19578 wxPyEndAllowThreads(__tstate);
19579 if (PyErr_Occurred()) SWIG_fail;
19580 }
19581 resultobj = SWIG_From_int(static_cast< int >(result));
19582 return resultobj;
19583 fail:
19584 return NULL;
19585 }
19586
19587
19588 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19589 PyObject *resultobj = 0;
19590 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19591 int arg2 ;
19592 void *argp1 = 0 ;
19593 int res1 = 0 ;
19594 int val2 ;
19595 int ecode2 = 0 ;
19596 PyObject * obj0 = 0 ;
19597 PyObject * obj1 = 0 ;
19598 char * kwnames[] = {
19599 (char *) "self",(char *) "orient", NULL
19600 };
19601
19602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19604 if (!SWIG_IsOK(res1)) {
19605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19606 }
19607 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19608 ecode2 = SWIG_AsVal_int(obj1, &val2);
19609 if (!SWIG_IsOK(ecode2)) {
19610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19611 }
19612 arg2 = static_cast< int >(val2);
19613 {
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 (arg1)->SetOrientation(arg2);
19616 wxPyEndAllowThreads(__tstate);
19617 if (PyErr_Occurred()) SWIG_fail;
19618 }
19619 resultobj = SWIG_Py_Void();
19620 return resultobj;
19621 fail:
19622 return NULL;
19623 }
19624
19625
19626 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19627 PyObject *resultobj = 0;
19628 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19629 int arg2 ;
19630 void *argp1 = 0 ;
19631 int res1 = 0 ;
19632 int val2 ;
19633 int ecode2 = 0 ;
19634 PyObject * obj0 = 0 ;
19635 PyObject * obj1 = 0 ;
19636 char * kwnames[] = {
19637 (char *) "self",(char *) "pos", NULL
19638 };
19639
19640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19642 if (!SWIG_IsOK(res1)) {
19643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19644 }
19645 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19646 ecode2 = SWIG_AsVal_int(obj1, &val2);
19647 if (!SWIG_IsOK(ecode2)) {
19648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19649 }
19650 arg2 = static_cast< int >(val2);
19651 {
19652 PyThreadState* __tstate = wxPyBeginAllowThreads();
19653 (arg1)->SetPosition(arg2);
19654 wxPyEndAllowThreads(__tstate);
19655 if (PyErr_Occurred()) SWIG_fail;
19656 }
19657 resultobj = SWIG_Py_Void();
19658 return resultobj;
19659 fail:
19660 return NULL;
19661 }
19662
19663
19664 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19665 PyObject *obj;
19666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19667 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19668 return SWIG_Py_Void();
19669 }
19670
19671 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19672 return SWIG_Python_InitShadowInstance(args);
19673 }
19674
19675 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19676 PyObject *resultobj = 0;
19677 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19678 wxMouseEvent *result = 0 ;
19679 int val1 ;
19680 int ecode1 = 0 ;
19681 PyObject * obj0 = 0 ;
19682 char * kwnames[] = {
19683 (char *) "mouseType", NULL
19684 };
19685
19686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19687 if (obj0) {
19688 ecode1 = SWIG_AsVal_int(obj0, &val1);
19689 if (!SWIG_IsOK(ecode1)) {
19690 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19691 }
19692 arg1 = static_cast< wxEventType >(val1);
19693 }
19694 {
19695 PyThreadState* __tstate = wxPyBeginAllowThreads();
19696 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19697 wxPyEndAllowThreads(__tstate);
19698 if (PyErr_Occurred()) SWIG_fail;
19699 }
19700 {
19701 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19702 }
19703 return resultobj;
19704 fail:
19705 return NULL;
19706 }
19707
19708
19709 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19710 PyObject *resultobj = 0;
19711 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19712 bool result;
19713 void *argp1 = 0 ;
19714 int res1 = 0 ;
19715 PyObject *swig_obj[1] ;
19716
19717 if (!args) SWIG_fail;
19718 swig_obj[0] = args;
19719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19720 if (!SWIG_IsOK(res1)) {
19721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19722 }
19723 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19724 {
19725 PyThreadState* __tstate = wxPyBeginAllowThreads();
19726 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19727 wxPyEndAllowThreads(__tstate);
19728 if (PyErr_Occurred()) SWIG_fail;
19729 }
19730 {
19731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19732 }
19733 return resultobj;
19734 fail:
19735 return NULL;
19736 }
19737
19738
19739 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19740 PyObject *resultobj = 0;
19741 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19742 int arg2 = (int) wxMOUSE_BTN_ANY ;
19743 bool result;
19744 void *argp1 = 0 ;
19745 int res1 = 0 ;
19746 int val2 ;
19747 int ecode2 = 0 ;
19748 PyObject * obj0 = 0 ;
19749 PyObject * obj1 = 0 ;
19750 char * kwnames[] = {
19751 (char *) "self",(char *) "but", NULL
19752 };
19753
19754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19756 if (!SWIG_IsOK(res1)) {
19757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19758 }
19759 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19760 if (obj1) {
19761 ecode2 = SWIG_AsVal_int(obj1, &val2);
19762 if (!SWIG_IsOK(ecode2)) {
19763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19764 }
19765 arg2 = static_cast< int >(val2);
19766 }
19767 {
19768 PyThreadState* __tstate = wxPyBeginAllowThreads();
19769 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19770 wxPyEndAllowThreads(__tstate);
19771 if (PyErr_Occurred()) SWIG_fail;
19772 }
19773 {
19774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19775 }
19776 return resultobj;
19777 fail:
19778 return NULL;
19779 }
19780
19781
19782 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19783 PyObject *resultobj = 0;
19784 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19785 int arg2 = (int) wxMOUSE_BTN_ANY ;
19786 bool result;
19787 void *argp1 = 0 ;
19788 int res1 = 0 ;
19789 int val2 ;
19790 int ecode2 = 0 ;
19791 PyObject * obj0 = 0 ;
19792 PyObject * obj1 = 0 ;
19793 char * kwnames[] = {
19794 (char *) "self",(char *) "but", NULL
19795 };
19796
19797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19799 if (!SWIG_IsOK(res1)) {
19800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19801 }
19802 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19803 if (obj1) {
19804 ecode2 = SWIG_AsVal_int(obj1, &val2);
19805 if (!SWIG_IsOK(ecode2)) {
19806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19807 }
19808 arg2 = static_cast< int >(val2);
19809 }
19810 {
19811 PyThreadState* __tstate = wxPyBeginAllowThreads();
19812 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19813 wxPyEndAllowThreads(__tstate);
19814 if (PyErr_Occurred()) SWIG_fail;
19815 }
19816 {
19817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19818 }
19819 return resultobj;
19820 fail:
19821 return NULL;
19822 }
19823
19824
19825 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19826 PyObject *resultobj = 0;
19827 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19828 int arg2 = (int) wxMOUSE_BTN_ANY ;
19829 bool result;
19830 void *argp1 = 0 ;
19831 int res1 = 0 ;
19832 int val2 ;
19833 int ecode2 = 0 ;
19834 PyObject * obj0 = 0 ;
19835 PyObject * obj1 = 0 ;
19836 char * kwnames[] = {
19837 (char *) "self",(char *) "but", NULL
19838 };
19839
19840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19842 if (!SWIG_IsOK(res1)) {
19843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19844 }
19845 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19846 if (obj1) {
19847 ecode2 = SWIG_AsVal_int(obj1, &val2);
19848 if (!SWIG_IsOK(ecode2)) {
19849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19850 }
19851 arg2 = static_cast< int >(val2);
19852 }
19853 {
19854 PyThreadState* __tstate = wxPyBeginAllowThreads();
19855 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19856 wxPyEndAllowThreads(__tstate);
19857 if (PyErr_Occurred()) SWIG_fail;
19858 }
19859 {
19860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19861 }
19862 return resultobj;
19863 fail:
19864 return NULL;
19865 }
19866
19867
19868 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19869 PyObject *resultobj = 0;
19870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19871 int arg2 ;
19872 bool result;
19873 void *argp1 = 0 ;
19874 int res1 = 0 ;
19875 int val2 ;
19876 int ecode2 = 0 ;
19877 PyObject * obj0 = 0 ;
19878 PyObject * obj1 = 0 ;
19879 char * kwnames[] = {
19880 (char *) "self",(char *) "button", NULL
19881 };
19882
19883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19885 if (!SWIG_IsOK(res1)) {
19886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19887 }
19888 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19889 ecode2 = SWIG_AsVal_int(obj1, &val2);
19890 if (!SWIG_IsOK(ecode2)) {
19891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19892 }
19893 arg2 = static_cast< int >(val2);
19894 {
19895 PyThreadState* __tstate = wxPyBeginAllowThreads();
19896 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19897 wxPyEndAllowThreads(__tstate);
19898 if (PyErr_Occurred()) SWIG_fail;
19899 }
19900 {
19901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19902 }
19903 return resultobj;
19904 fail:
19905 return NULL;
19906 }
19907
19908
19909 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19910 PyObject *resultobj = 0;
19911 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19912 int arg2 ;
19913 bool result;
19914 void *argp1 = 0 ;
19915 int res1 = 0 ;
19916 int val2 ;
19917 int ecode2 = 0 ;
19918 PyObject * obj0 = 0 ;
19919 PyObject * obj1 = 0 ;
19920 char * kwnames[] = {
19921 (char *) "self",(char *) "but", NULL
19922 };
19923
19924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19926 if (!SWIG_IsOK(res1)) {
19927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19928 }
19929 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19930 ecode2 = SWIG_AsVal_int(obj1, &val2);
19931 if (!SWIG_IsOK(ecode2)) {
19932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
19933 }
19934 arg2 = static_cast< int >(val2);
19935 {
19936 PyThreadState* __tstate = wxPyBeginAllowThreads();
19937 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
19938 wxPyEndAllowThreads(__tstate);
19939 if (PyErr_Occurred()) SWIG_fail;
19940 }
19941 {
19942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19943 }
19944 return resultobj;
19945 fail:
19946 return NULL;
19947 }
19948
19949
19950 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19951 PyObject *resultobj = 0;
19952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19953 int result;
19954 void *argp1 = 0 ;
19955 int res1 = 0 ;
19956 PyObject *swig_obj[1] ;
19957
19958 if (!args) SWIG_fail;
19959 swig_obj[0] = args;
19960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19961 if (!SWIG_IsOK(res1)) {
19962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19963 }
19964 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19965 {
19966 PyThreadState* __tstate = wxPyBeginAllowThreads();
19967 result = (int)((wxMouseEvent const *)arg1)->GetButton();
19968 wxPyEndAllowThreads(__tstate);
19969 if (PyErr_Occurred()) SWIG_fail;
19970 }
19971 resultobj = SWIG_From_int(static_cast< int >(result));
19972 return resultobj;
19973 fail:
19974 return NULL;
19975 }
19976
19977
19978 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19979 PyObject *resultobj = 0;
19980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19981 bool result;
19982 void *argp1 = 0 ;
19983 int res1 = 0 ;
19984 PyObject *swig_obj[1] ;
19985
19986 if (!args) SWIG_fail;
19987 swig_obj[0] = args;
19988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19989 if (!SWIG_IsOK(res1)) {
19990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19991 }
19992 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19993 {
19994 PyThreadState* __tstate = wxPyBeginAllowThreads();
19995 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
19996 wxPyEndAllowThreads(__tstate);
19997 if (PyErr_Occurred()) SWIG_fail;
19998 }
19999 {
20000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20001 }
20002 return resultobj;
20003 fail:
20004 return NULL;
20005 }
20006
20007
20008 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20009 PyObject *resultobj = 0;
20010 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20011 bool result;
20012 void *argp1 = 0 ;
20013 int res1 = 0 ;
20014 PyObject *swig_obj[1] ;
20015
20016 if (!args) SWIG_fail;
20017 swig_obj[0] = args;
20018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20019 if (!SWIG_IsOK(res1)) {
20020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20021 }
20022 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20023 {
20024 PyThreadState* __tstate = wxPyBeginAllowThreads();
20025 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20026 wxPyEndAllowThreads(__tstate);
20027 if (PyErr_Occurred()) SWIG_fail;
20028 }
20029 {
20030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20031 }
20032 return resultobj;
20033 fail:
20034 return NULL;
20035 }
20036
20037
20038 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20039 PyObject *resultobj = 0;
20040 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20041 bool result;
20042 void *argp1 = 0 ;
20043 int res1 = 0 ;
20044 PyObject *swig_obj[1] ;
20045
20046 if (!args) SWIG_fail;
20047 swig_obj[0] = args;
20048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20049 if (!SWIG_IsOK(res1)) {
20050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20051 }
20052 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20053 {
20054 PyThreadState* __tstate = wxPyBeginAllowThreads();
20055 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20056 wxPyEndAllowThreads(__tstate);
20057 if (PyErr_Occurred()) SWIG_fail;
20058 }
20059 {
20060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20061 }
20062 return resultobj;
20063 fail:
20064 return NULL;
20065 }
20066
20067
20068 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20069 PyObject *resultobj = 0;
20070 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20071 bool result;
20072 void *argp1 = 0 ;
20073 int res1 = 0 ;
20074 PyObject *swig_obj[1] ;
20075
20076 if (!args) SWIG_fail;
20077 swig_obj[0] = args;
20078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20079 if (!SWIG_IsOK(res1)) {
20080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20081 }
20082 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20083 {
20084 PyThreadState* __tstate = wxPyBeginAllowThreads();
20085 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20086 wxPyEndAllowThreads(__tstate);
20087 if (PyErr_Occurred()) SWIG_fail;
20088 }
20089 {
20090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20091 }
20092 return resultobj;
20093 fail:
20094 return NULL;
20095 }
20096
20097
20098 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20099 PyObject *resultobj = 0;
20100 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20101 bool result;
20102 void *argp1 = 0 ;
20103 int res1 = 0 ;
20104 PyObject *swig_obj[1] ;
20105
20106 if (!args) SWIG_fail;
20107 swig_obj[0] = args;
20108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20109 if (!SWIG_IsOK(res1)) {
20110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20111 }
20112 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20113 {
20114 PyThreadState* __tstate = wxPyBeginAllowThreads();
20115 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20116 wxPyEndAllowThreads(__tstate);
20117 if (PyErr_Occurred()) SWIG_fail;
20118 }
20119 {
20120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20121 }
20122 return resultobj;
20123 fail:
20124 return NULL;
20125 }
20126
20127
20128 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20129 PyObject *resultobj = 0;
20130 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20131 bool result;
20132 void *argp1 = 0 ;
20133 int res1 = 0 ;
20134 PyObject *swig_obj[1] ;
20135
20136 if (!args) SWIG_fail;
20137 swig_obj[0] = args;
20138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20139 if (!SWIG_IsOK(res1)) {
20140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20141 }
20142 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20143 {
20144 PyThreadState* __tstate = wxPyBeginAllowThreads();
20145 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20146 wxPyEndAllowThreads(__tstate);
20147 if (PyErr_Occurred()) SWIG_fail;
20148 }
20149 {
20150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20151 }
20152 return resultobj;
20153 fail:
20154 return NULL;
20155 }
20156
20157
20158 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20159 PyObject *resultobj = 0;
20160 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20161 bool result;
20162 void *argp1 = 0 ;
20163 int res1 = 0 ;
20164 PyObject *swig_obj[1] ;
20165
20166 if (!args) SWIG_fail;
20167 swig_obj[0] = args;
20168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20169 if (!SWIG_IsOK(res1)) {
20170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20171 }
20172 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20173 {
20174 PyThreadState* __tstate = wxPyBeginAllowThreads();
20175 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20176 wxPyEndAllowThreads(__tstate);
20177 if (PyErr_Occurred()) SWIG_fail;
20178 }
20179 {
20180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20181 }
20182 return resultobj;
20183 fail:
20184 return NULL;
20185 }
20186
20187
20188 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20189 PyObject *resultobj = 0;
20190 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20191 bool result;
20192 void *argp1 = 0 ;
20193 int res1 = 0 ;
20194 PyObject *swig_obj[1] ;
20195
20196 if (!args) SWIG_fail;
20197 swig_obj[0] = args;
20198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20199 if (!SWIG_IsOK(res1)) {
20200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20201 }
20202 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20203 {
20204 PyThreadState* __tstate = wxPyBeginAllowThreads();
20205 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20206 wxPyEndAllowThreads(__tstate);
20207 if (PyErr_Occurred()) SWIG_fail;
20208 }
20209 {
20210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20211 }
20212 return resultobj;
20213 fail:
20214 return NULL;
20215 }
20216
20217
20218 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20219 PyObject *resultobj = 0;
20220 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20221 bool result;
20222 void *argp1 = 0 ;
20223 int res1 = 0 ;
20224 PyObject *swig_obj[1] ;
20225
20226 if (!args) SWIG_fail;
20227 swig_obj[0] = args;
20228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20229 if (!SWIG_IsOK(res1)) {
20230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20231 }
20232 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20233 {
20234 PyThreadState* __tstate = wxPyBeginAllowThreads();
20235 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20236 wxPyEndAllowThreads(__tstate);
20237 if (PyErr_Occurred()) SWIG_fail;
20238 }
20239 {
20240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20241 }
20242 return resultobj;
20243 fail:
20244 return NULL;
20245 }
20246
20247
20248 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20249 PyObject *resultobj = 0;
20250 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20251 bool result;
20252 void *argp1 = 0 ;
20253 int res1 = 0 ;
20254 PyObject *swig_obj[1] ;
20255
20256 if (!args) SWIG_fail;
20257 swig_obj[0] = args;
20258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20259 if (!SWIG_IsOK(res1)) {
20260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20261 }
20262 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20263 {
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 {
20270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20271 }
20272 return resultobj;
20273 fail:
20274 return NULL;
20275 }
20276
20277
20278 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20279 PyObject *resultobj = 0;
20280 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20281 bool result;
20282 void *argp1 = 0 ;
20283 int res1 = 0 ;
20284 PyObject *swig_obj[1] ;
20285
20286 if (!args) SWIG_fail;
20287 swig_obj[0] = args;
20288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20289 if (!SWIG_IsOK(res1)) {
20290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20291 }
20292 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20293 {
20294 PyThreadState* __tstate = wxPyBeginAllowThreads();
20295 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20296 wxPyEndAllowThreads(__tstate);
20297 if (PyErr_Occurred()) SWIG_fail;
20298 }
20299 {
20300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20301 }
20302 return resultobj;
20303 fail:
20304 return NULL;
20305 }
20306
20307
20308 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20309 PyObject *resultobj = 0;
20310 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20311 bool result;
20312 void *argp1 = 0 ;
20313 int res1 = 0 ;
20314 PyObject *swig_obj[1] ;
20315
20316 if (!args) SWIG_fail;
20317 swig_obj[0] = args;
20318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20319 if (!SWIG_IsOK(res1)) {
20320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20321 }
20322 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20323 {
20324 PyThreadState* __tstate = wxPyBeginAllowThreads();
20325 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20326 wxPyEndAllowThreads(__tstate);
20327 if (PyErr_Occurred()) SWIG_fail;
20328 }
20329 {
20330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20331 }
20332 return resultobj;
20333 fail:
20334 return NULL;
20335 }
20336
20337
20338 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20339 PyObject *resultobj = 0;
20340 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20341 bool result;
20342 void *argp1 = 0 ;
20343 int res1 = 0 ;
20344 PyObject *swig_obj[1] ;
20345
20346 if (!args) SWIG_fail;
20347 swig_obj[0] = args;
20348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20349 if (!SWIG_IsOK(res1)) {
20350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20351 }
20352 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20353 {
20354 PyThreadState* __tstate = wxPyBeginAllowThreads();
20355 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20356 wxPyEndAllowThreads(__tstate);
20357 if (PyErr_Occurred()) SWIG_fail;
20358 }
20359 {
20360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20361 }
20362 return resultobj;
20363 fail:
20364 return NULL;
20365 }
20366
20367
20368 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20369 PyObject *resultobj = 0;
20370 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20371 bool result;
20372 void *argp1 = 0 ;
20373 int res1 = 0 ;
20374 PyObject *swig_obj[1] ;
20375
20376 if (!args) SWIG_fail;
20377 swig_obj[0] = args;
20378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20379 if (!SWIG_IsOK(res1)) {
20380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20381 }
20382 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20383 {
20384 PyThreadState* __tstate = wxPyBeginAllowThreads();
20385 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20386 wxPyEndAllowThreads(__tstate);
20387 if (PyErr_Occurred()) SWIG_fail;
20388 }
20389 {
20390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20391 }
20392 return resultobj;
20393 fail:
20394 return NULL;
20395 }
20396
20397
20398 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20399 PyObject *resultobj = 0;
20400 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20401 bool result;
20402 void *argp1 = 0 ;
20403 int res1 = 0 ;
20404 PyObject *swig_obj[1] ;
20405
20406 if (!args) SWIG_fail;
20407 swig_obj[0] = args;
20408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20409 if (!SWIG_IsOK(res1)) {
20410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20411 }
20412 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20413 {
20414 PyThreadState* __tstate = wxPyBeginAllowThreads();
20415 result = (bool)(arg1)->LeftIsDown();
20416 wxPyEndAllowThreads(__tstate);
20417 if (PyErr_Occurred()) SWIG_fail;
20418 }
20419 {
20420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20421 }
20422 return resultobj;
20423 fail:
20424 return NULL;
20425 }
20426
20427
20428 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20429 PyObject *resultobj = 0;
20430 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20431 bool result;
20432 void *argp1 = 0 ;
20433 int res1 = 0 ;
20434 PyObject *swig_obj[1] ;
20435
20436 if (!args) SWIG_fail;
20437 swig_obj[0] = args;
20438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20439 if (!SWIG_IsOK(res1)) {
20440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20441 }
20442 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20443 {
20444 PyThreadState* __tstate = wxPyBeginAllowThreads();
20445 result = (bool)(arg1)->MiddleIsDown();
20446 wxPyEndAllowThreads(__tstate);
20447 if (PyErr_Occurred()) SWIG_fail;
20448 }
20449 {
20450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20451 }
20452 return resultobj;
20453 fail:
20454 return NULL;
20455 }
20456
20457
20458 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20459 PyObject *resultobj = 0;
20460 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20461 bool result;
20462 void *argp1 = 0 ;
20463 int res1 = 0 ;
20464 PyObject *swig_obj[1] ;
20465
20466 if (!args) SWIG_fail;
20467 swig_obj[0] = args;
20468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20469 if (!SWIG_IsOK(res1)) {
20470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20471 }
20472 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20473 {
20474 PyThreadState* __tstate = wxPyBeginAllowThreads();
20475 result = (bool)(arg1)->RightIsDown();
20476 wxPyEndAllowThreads(__tstate);
20477 if (PyErr_Occurred()) SWIG_fail;
20478 }
20479 {
20480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20481 }
20482 return resultobj;
20483 fail:
20484 return NULL;
20485 }
20486
20487
20488 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20489 PyObject *resultobj = 0;
20490 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20491 bool result;
20492 void *argp1 = 0 ;
20493 int res1 = 0 ;
20494 PyObject *swig_obj[1] ;
20495
20496 if (!args) SWIG_fail;
20497 swig_obj[0] = args;
20498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20499 if (!SWIG_IsOK(res1)) {
20500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20501 }
20502 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20503 {
20504 PyThreadState* __tstate = wxPyBeginAllowThreads();
20505 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20506 wxPyEndAllowThreads(__tstate);
20507 if (PyErr_Occurred()) SWIG_fail;
20508 }
20509 {
20510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20511 }
20512 return resultobj;
20513 fail:
20514 return NULL;
20515 }
20516
20517
20518 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20519 PyObject *resultobj = 0;
20520 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20521 bool result;
20522 void *argp1 = 0 ;
20523 int res1 = 0 ;
20524 PyObject *swig_obj[1] ;
20525
20526 if (!args) SWIG_fail;
20527 swig_obj[0] = args;
20528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20529 if (!SWIG_IsOK(res1)) {
20530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20531 }
20532 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20533 {
20534 PyThreadState* __tstate = wxPyBeginAllowThreads();
20535 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20536 wxPyEndAllowThreads(__tstate);
20537 if (PyErr_Occurred()) SWIG_fail;
20538 }
20539 {
20540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20541 }
20542 return resultobj;
20543 fail:
20544 return NULL;
20545 }
20546
20547
20548 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20549 PyObject *resultobj = 0;
20550 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20551 bool result;
20552 void *argp1 = 0 ;
20553 int res1 = 0 ;
20554 PyObject *swig_obj[1] ;
20555
20556 if (!args) SWIG_fail;
20557 swig_obj[0] = args;
20558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20559 if (!SWIG_IsOK(res1)) {
20560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20561 }
20562 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20563 {
20564 PyThreadState* __tstate = wxPyBeginAllowThreads();
20565 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20566 wxPyEndAllowThreads(__tstate);
20567 if (PyErr_Occurred()) SWIG_fail;
20568 }
20569 {
20570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20571 }
20572 return resultobj;
20573 fail:
20574 return NULL;
20575 }
20576
20577
20578 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20579 PyObject *resultobj = 0;
20580 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20581 bool result;
20582 void *argp1 = 0 ;
20583 int res1 = 0 ;
20584 PyObject *swig_obj[1] ;
20585
20586 if (!args) SWIG_fail;
20587 swig_obj[0] = args;
20588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20589 if (!SWIG_IsOK(res1)) {
20590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20591 }
20592 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20593 {
20594 PyThreadState* __tstate = wxPyBeginAllowThreads();
20595 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20596 wxPyEndAllowThreads(__tstate);
20597 if (PyErr_Occurred()) SWIG_fail;
20598 }
20599 {
20600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20601 }
20602 return resultobj;
20603 fail:
20604 return NULL;
20605 }
20606
20607
20608 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20609 PyObject *resultobj = 0;
20610 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20611 wxPoint result;
20612 void *argp1 = 0 ;
20613 int res1 = 0 ;
20614 PyObject *swig_obj[1] ;
20615
20616 if (!args) SWIG_fail;
20617 swig_obj[0] = args;
20618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20619 if (!SWIG_IsOK(res1)) {
20620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20621 }
20622 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20623 {
20624 PyThreadState* __tstate = wxPyBeginAllowThreads();
20625 result = (arg1)->GetPosition();
20626 wxPyEndAllowThreads(__tstate);
20627 if (PyErr_Occurred()) SWIG_fail;
20628 }
20629 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20630 return resultobj;
20631 fail:
20632 return NULL;
20633 }
20634
20635
20636 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20637 PyObject *resultobj = 0;
20638 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20639 long *arg2 = (long *) 0 ;
20640 long *arg3 = (long *) 0 ;
20641 void *argp1 = 0 ;
20642 int res1 = 0 ;
20643 long temp2 ;
20644 int res2 = SWIG_TMPOBJ ;
20645 long temp3 ;
20646 int res3 = SWIG_TMPOBJ ;
20647 PyObject *swig_obj[1] ;
20648
20649 arg2 = &temp2;
20650 arg3 = &temp3;
20651 if (!args) SWIG_fail;
20652 swig_obj[0] = args;
20653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20654 if (!SWIG_IsOK(res1)) {
20655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20656 }
20657 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20658 {
20659 PyThreadState* __tstate = wxPyBeginAllowThreads();
20660 (arg1)->GetPosition(arg2,arg3);
20661 wxPyEndAllowThreads(__tstate);
20662 if (PyErr_Occurred()) SWIG_fail;
20663 }
20664 resultobj = SWIG_Py_Void();
20665 if (SWIG_IsTmpObj(res2)) {
20666 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20667 } else {
20668 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20669 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20670 }
20671 if (SWIG_IsTmpObj(res3)) {
20672 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20673 } else {
20674 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20675 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20676 }
20677 return resultobj;
20678 fail:
20679 return NULL;
20680 }
20681
20682
20683 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20684 PyObject *resultobj = 0;
20685 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20686 wxDC *arg2 = 0 ;
20687 wxPoint result;
20688 void *argp1 = 0 ;
20689 int res1 = 0 ;
20690 void *argp2 = 0 ;
20691 int res2 = 0 ;
20692 PyObject * obj0 = 0 ;
20693 PyObject * obj1 = 0 ;
20694 char * kwnames[] = {
20695 (char *) "self",(char *) "dc", NULL
20696 };
20697
20698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20700 if (!SWIG_IsOK(res1)) {
20701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20702 }
20703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20704 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20705 if (!SWIG_IsOK(res2)) {
20706 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20707 }
20708 if (!argp2) {
20709 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20710 }
20711 arg2 = reinterpret_cast< wxDC * >(argp2);
20712 {
20713 PyThreadState* __tstate = wxPyBeginAllowThreads();
20714 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20715 wxPyEndAllowThreads(__tstate);
20716 if (PyErr_Occurred()) SWIG_fail;
20717 }
20718 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20719 return resultobj;
20720 fail:
20721 return NULL;
20722 }
20723
20724
20725 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20726 PyObject *resultobj = 0;
20727 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20728 int result;
20729 void *argp1 = 0 ;
20730 int res1 = 0 ;
20731 PyObject *swig_obj[1] ;
20732
20733 if (!args) SWIG_fail;
20734 swig_obj[0] = args;
20735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20736 if (!SWIG_IsOK(res1)) {
20737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20738 }
20739 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20740 {
20741 PyThreadState* __tstate = wxPyBeginAllowThreads();
20742 result = (int)((wxMouseEvent const *)arg1)->GetX();
20743 wxPyEndAllowThreads(__tstate);
20744 if (PyErr_Occurred()) SWIG_fail;
20745 }
20746 resultobj = SWIG_From_int(static_cast< int >(result));
20747 return resultobj;
20748 fail:
20749 return NULL;
20750 }
20751
20752
20753 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20754 PyObject *resultobj = 0;
20755 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20756 int result;
20757 void *argp1 = 0 ;
20758 int res1 = 0 ;
20759 PyObject *swig_obj[1] ;
20760
20761 if (!args) SWIG_fail;
20762 swig_obj[0] = args;
20763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20764 if (!SWIG_IsOK(res1)) {
20765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20766 }
20767 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20768 {
20769 PyThreadState* __tstate = wxPyBeginAllowThreads();
20770 result = (int)((wxMouseEvent const *)arg1)->GetY();
20771 wxPyEndAllowThreads(__tstate);
20772 if (PyErr_Occurred()) SWIG_fail;
20773 }
20774 resultobj = SWIG_From_int(static_cast< int >(result));
20775 return resultobj;
20776 fail:
20777 return NULL;
20778 }
20779
20780
20781 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20782 PyObject *resultobj = 0;
20783 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20784 int result;
20785 void *argp1 = 0 ;
20786 int res1 = 0 ;
20787 PyObject *swig_obj[1] ;
20788
20789 if (!args) SWIG_fail;
20790 swig_obj[0] = args;
20791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20792 if (!SWIG_IsOK(res1)) {
20793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20794 }
20795 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20796 {
20797 PyThreadState* __tstate = wxPyBeginAllowThreads();
20798 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20799 wxPyEndAllowThreads(__tstate);
20800 if (PyErr_Occurred()) SWIG_fail;
20801 }
20802 resultobj = SWIG_From_int(static_cast< int >(result));
20803 return resultobj;
20804 fail:
20805 return NULL;
20806 }
20807
20808
20809 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20810 PyObject *resultobj = 0;
20811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20812 int result;
20813 void *argp1 = 0 ;
20814 int res1 = 0 ;
20815 PyObject *swig_obj[1] ;
20816
20817 if (!args) SWIG_fail;
20818 swig_obj[0] = args;
20819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20820 if (!SWIG_IsOK(res1)) {
20821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20822 }
20823 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20824 {
20825 PyThreadState* __tstate = wxPyBeginAllowThreads();
20826 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20827 wxPyEndAllowThreads(__tstate);
20828 if (PyErr_Occurred()) SWIG_fail;
20829 }
20830 resultobj = SWIG_From_int(static_cast< int >(result));
20831 return resultobj;
20832 fail:
20833 return NULL;
20834 }
20835
20836
20837 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20838 PyObject *resultobj = 0;
20839 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20840 int result;
20841 void *argp1 = 0 ;
20842 int res1 = 0 ;
20843 PyObject *swig_obj[1] ;
20844
20845 if (!args) SWIG_fail;
20846 swig_obj[0] = args;
20847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20848 if (!SWIG_IsOK(res1)) {
20849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20850 }
20851 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20852 {
20853 PyThreadState* __tstate = wxPyBeginAllowThreads();
20854 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20855 wxPyEndAllowThreads(__tstate);
20856 if (PyErr_Occurred()) SWIG_fail;
20857 }
20858 resultobj = SWIG_From_int(static_cast< int >(result));
20859 return resultobj;
20860 fail:
20861 return NULL;
20862 }
20863
20864
20865 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20866 PyObject *resultobj = 0;
20867 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20868 bool result;
20869 void *argp1 = 0 ;
20870 int res1 = 0 ;
20871 PyObject *swig_obj[1] ;
20872
20873 if (!args) SWIG_fail;
20874 swig_obj[0] = args;
20875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20876 if (!SWIG_IsOK(res1)) {
20877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20878 }
20879 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20880 {
20881 PyThreadState* __tstate = wxPyBeginAllowThreads();
20882 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20883 wxPyEndAllowThreads(__tstate);
20884 if (PyErr_Occurred()) SWIG_fail;
20885 }
20886 {
20887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20888 }
20889 return resultobj;
20890 fail:
20891 return NULL;
20892 }
20893
20894
20895 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20896 PyObject *resultobj = 0;
20897 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20898 int arg2 ;
20899 void *argp1 = 0 ;
20900 int res1 = 0 ;
20901 int val2 ;
20902 int ecode2 = 0 ;
20903 PyObject *swig_obj[2] ;
20904
20905 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20907 if (!SWIG_IsOK(res1)) {
20908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20909 }
20910 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20911 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20912 if (!SWIG_IsOK(ecode2)) {
20913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20914 }
20915 arg2 = static_cast< int >(val2);
20916 if (arg1) (arg1)->m_x = arg2;
20917
20918 resultobj = SWIG_Py_Void();
20919 return resultobj;
20920 fail:
20921 return NULL;
20922 }
20923
20924
20925 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20926 PyObject *resultobj = 0;
20927 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20928 int result;
20929 void *argp1 = 0 ;
20930 int res1 = 0 ;
20931 PyObject *swig_obj[1] ;
20932
20933 if (!args) SWIG_fail;
20934 swig_obj[0] = args;
20935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20936 if (!SWIG_IsOK(res1)) {
20937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20938 }
20939 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20940 result = (int) ((arg1)->m_x);
20941 resultobj = SWIG_From_int(static_cast< int >(result));
20942 return resultobj;
20943 fail:
20944 return NULL;
20945 }
20946
20947
20948 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20949 PyObject *resultobj = 0;
20950 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20951 int arg2 ;
20952 void *argp1 = 0 ;
20953 int res1 = 0 ;
20954 int val2 ;
20955 int ecode2 = 0 ;
20956 PyObject *swig_obj[2] ;
20957
20958 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
20959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20960 if (!SWIG_IsOK(res1)) {
20961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20962 }
20963 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20964 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20965 if (!SWIG_IsOK(ecode2)) {
20966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
20967 }
20968 arg2 = static_cast< int >(val2);
20969 if (arg1) (arg1)->m_y = arg2;
20970
20971 resultobj = SWIG_Py_Void();
20972 return resultobj;
20973 fail:
20974 return NULL;
20975 }
20976
20977
20978 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20979 PyObject *resultobj = 0;
20980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20981 int result;
20982 void *argp1 = 0 ;
20983 int res1 = 0 ;
20984 PyObject *swig_obj[1] ;
20985
20986 if (!args) SWIG_fail;
20987 swig_obj[0] = args;
20988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20989 if (!SWIG_IsOK(res1)) {
20990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20991 }
20992 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20993 result = (int) ((arg1)->m_y);
20994 resultobj = SWIG_From_int(static_cast< int >(result));
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21002 PyObject *resultobj = 0;
21003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21004 bool arg2 ;
21005 void *argp1 = 0 ;
21006 int res1 = 0 ;
21007 bool val2 ;
21008 int ecode2 = 0 ;
21009 PyObject *swig_obj[2] ;
21010
21011 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21013 if (!SWIG_IsOK(res1)) {
21014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21015 }
21016 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21017 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21018 if (!SWIG_IsOK(ecode2)) {
21019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21020 }
21021 arg2 = static_cast< bool >(val2);
21022 if (arg1) (arg1)->m_leftDown = arg2;
21023
21024 resultobj = SWIG_Py_Void();
21025 return resultobj;
21026 fail:
21027 return NULL;
21028 }
21029
21030
21031 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21032 PyObject *resultobj = 0;
21033 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21034 bool result;
21035 void *argp1 = 0 ;
21036 int res1 = 0 ;
21037 PyObject *swig_obj[1] ;
21038
21039 if (!args) SWIG_fail;
21040 swig_obj[0] = args;
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_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21044 }
21045 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21046 result = (bool) ((arg1)->m_leftDown);
21047 {
21048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21049 }
21050 return resultobj;
21051 fail:
21052 return NULL;
21053 }
21054
21055
21056 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21057 PyObject *resultobj = 0;
21058 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21059 bool arg2 ;
21060 void *argp1 = 0 ;
21061 int res1 = 0 ;
21062 bool val2 ;
21063 int ecode2 = 0 ;
21064 PyObject *swig_obj[2] ;
21065
21066 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21068 if (!SWIG_IsOK(res1)) {
21069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21070 }
21071 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21072 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21073 if (!SWIG_IsOK(ecode2)) {
21074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21075 }
21076 arg2 = static_cast< bool >(val2);
21077 if (arg1) (arg1)->m_middleDown = arg2;
21078
21079 resultobj = SWIG_Py_Void();
21080 return resultobj;
21081 fail:
21082 return NULL;
21083 }
21084
21085
21086 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21087 PyObject *resultobj = 0;
21088 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21089 bool result;
21090 void *argp1 = 0 ;
21091 int res1 = 0 ;
21092 PyObject *swig_obj[1] ;
21093
21094 if (!args) SWIG_fail;
21095 swig_obj[0] = args;
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_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21099 }
21100 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21101 result = (bool) ((arg1)->m_middleDown);
21102 {
21103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21104 }
21105 return resultobj;
21106 fail:
21107 return NULL;
21108 }
21109
21110
21111 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21112 PyObject *resultobj = 0;
21113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21114 bool arg2 ;
21115 void *argp1 = 0 ;
21116 int res1 = 0 ;
21117 bool val2 ;
21118 int ecode2 = 0 ;
21119 PyObject *swig_obj[2] ;
21120
21121 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21123 if (!SWIG_IsOK(res1)) {
21124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21125 }
21126 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21127 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21128 if (!SWIG_IsOK(ecode2)) {
21129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21130 }
21131 arg2 = static_cast< bool >(val2);
21132 if (arg1) (arg1)->m_rightDown = arg2;
21133
21134 resultobj = SWIG_Py_Void();
21135 return resultobj;
21136 fail:
21137 return NULL;
21138 }
21139
21140
21141 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21142 PyObject *resultobj = 0;
21143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21144 bool result;
21145 void *argp1 = 0 ;
21146 int res1 = 0 ;
21147 PyObject *swig_obj[1] ;
21148
21149 if (!args) SWIG_fail;
21150 swig_obj[0] = args;
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_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21154 }
21155 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21156 result = (bool) ((arg1)->m_rightDown);
21157 {
21158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21159 }
21160 return resultobj;
21161 fail:
21162 return NULL;
21163 }
21164
21165
21166 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21167 PyObject *resultobj = 0;
21168 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21169 bool arg2 ;
21170 void *argp1 = 0 ;
21171 int res1 = 0 ;
21172 bool val2 ;
21173 int ecode2 = 0 ;
21174 PyObject *swig_obj[2] ;
21175
21176 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21178 if (!SWIG_IsOK(res1)) {
21179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21180 }
21181 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21182 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21183 if (!SWIG_IsOK(ecode2)) {
21184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21185 }
21186 arg2 = static_cast< bool >(val2);
21187 if (arg1) (arg1)->m_controlDown = arg2;
21188
21189 resultobj = SWIG_Py_Void();
21190 return resultobj;
21191 fail:
21192 return NULL;
21193 }
21194
21195
21196 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21197 PyObject *resultobj = 0;
21198 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21199 bool result;
21200 void *argp1 = 0 ;
21201 int res1 = 0 ;
21202 PyObject *swig_obj[1] ;
21203
21204 if (!args) SWIG_fail;
21205 swig_obj[0] = args;
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_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21209 }
21210 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21211 result = (bool) ((arg1)->m_controlDown);
21212 {
21213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21214 }
21215 return resultobj;
21216 fail:
21217 return NULL;
21218 }
21219
21220
21221 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21222 PyObject *resultobj = 0;
21223 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21224 bool arg2 ;
21225 void *argp1 = 0 ;
21226 int res1 = 0 ;
21227 bool val2 ;
21228 int ecode2 = 0 ;
21229 PyObject *swig_obj[2] ;
21230
21231 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21233 if (!SWIG_IsOK(res1)) {
21234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21235 }
21236 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21237 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21238 if (!SWIG_IsOK(ecode2)) {
21239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21240 }
21241 arg2 = static_cast< bool >(val2);
21242 if (arg1) (arg1)->m_shiftDown = arg2;
21243
21244 resultobj = SWIG_Py_Void();
21245 return resultobj;
21246 fail:
21247 return NULL;
21248 }
21249
21250
21251 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21252 PyObject *resultobj = 0;
21253 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21254 bool result;
21255 void *argp1 = 0 ;
21256 int res1 = 0 ;
21257 PyObject *swig_obj[1] ;
21258
21259 if (!args) SWIG_fail;
21260 swig_obj[0] = args;
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_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21264 }
21265 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21266 result = (bool) ((arg1)->m_shiftDown);
21267 {
21268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21269 }
21270 return resultobj;
21271 fail:
21272 return NULL;
21273 }
21274
21275
21276 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21277 PyObject *resultobj = 0;
21278 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21279 bool arg2 ;
21280 void *argp1 = 0 ;
21281 int res1 = 0 ;
21282 bool val2 ;
21283 int ecode2 = 0 ;
21284 PyObject *swig_obj[2] ;
21285
21286 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21288 if (!SWIG_IsOK(res1)) {
21289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21290 }
21291 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21292 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21293 if (!SWIG_IsOK(ecode2)) {
21294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21295 }
21296 arg2 = static_cast< bool >(val2);
21297 if (arg1) (arg1)->m_altDown = arg2;
21298
21299 resultobj = SWIG_Py_Void();
21300 return resultobj;
21301 fail:
21302 return NULL;
21303 }
21304
21305
21306 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21307 PyObject *resultobj = 0;
21308 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21309 bool result;
21310 void *argp1 = 0 ;
21311 int res1 = 0 ;
21312 PyObject *swig_obj[1] ;
21313
21314 if (!args) SWIG_fail;
21315 swig_obj[0] = args;
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_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21319 }
21320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21321 result = (bool) ((arg1)->m_altDown);
21322 {
21323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21324 }
21325 return resultobj;
21326 fail:
21327 return NULL;
21328 }
21329
21330
21331 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21332 PyObject *resultobj = 0;
21333 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21334 bool arg2 ;
21335 void *argp1 = 0 ;
21336 int res1 = 0 ;
21337 bool val2 ;
21338 int ecode2 = 0 ;
21339 PyObject *swig_obj[2] ;
21340
21341 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21343 if (!SWIG_IsOK(res1)) {
21344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21345 }
21346 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21347 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21348 if (!SWIG_IsOK(ecode2)) {
21349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21350 }
21351 arg2 = static_cast< bool >(val2);
21352 if (arg1) (arg1)->m_metaDown = arg2;
21353
21354 resultobj = SWIG_Py_Void();
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21362 PyObject *resultobj = 0;
21363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21364 bool result;
21365 void *argp1 = 0 ;
21366 int res1 = 0 ;
21367 PyObject *swig_obj[1] ;
21368
21369 if (!args) SWIG_fail;
21370 swig_obj[0] = args;
21371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21372 if (!SWIG_IsOK(res1)) {
21373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21374 }
21375 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21376 result = (bool) ((arg1)->m_metaDown);
21377 {
21378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21379 }
21380 return resultobj;
21381 fail:
21382 return NULL;
21383 }
21384
21385
21386 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21387 PyObject *resultobj = 0;
21388 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21389 int arg2 ;
21390 void *argp1 = 0 ;
21391 int res1 = 0 ;
21392 int val2 ;
21393 int ecode2 = 0 ;
21394 PyObject *swig_obj[2] ;
21395
21396 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21398 if (!SWIG_IsOK(res1)) {
21399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21400 }
21401 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21402 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21403 if (!SWIG_IsOK(ecode2)) {
21404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21405 }
21406 arg2 = static_cast< int >(val2);
21407 if (arg1) (arg1)->m_wheelRotation = arg2;
21408
21409 resultobj = SWIG_Py_Void();
21410 return resultobj;
21411 fail:
21412 return NULL;
21413 }
21414
21415
21416 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21417 PyObject *resultobj = 0;
21418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21419 int result;
21420 void *argp1 = 0 ;
21421 int res1 = 0 ;
21422 PyObject *swig_obj[1] ;
21423
21424 if (!args) SWIG_fail;
21425 swig_obj[0] = args;
21426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21427 if (!SWIG_IsOK(res1)) {
21428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21429 }
21430 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21431 result = (int) ((arg1)->m_wheelRotation);
21432 resultobj = SWIG_From_int(static_cast< int >(result));
21433 return resultobj;
21434 fail:
21435 return NULL;
21436 }
21437
21438
21439 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21440 PyObject *resultobj = 0;
21441 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21442 int arg2 ;
21443 void *argp1 = 0 ;
21444 int res1 = 0 ;
21445 int val2 ;
21446 int ecode2 = 0 ;
21447 PyObject *swig_obj[2] ;
21448
21449 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21451 if (!SWIG_IsOK(res1)) {
21452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21453 }
21454 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21455 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21456 if (!SWIG_IsOK(ecode2)) {
21457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21458 }
21459 arg2 = static_cast< int >(val2);
21460 if (arg1) (arg1)->m_wheelDelta = arg2;
21461
21462 resultobj = SWIG_Py_Void();
21463 return resultobj;
21464 fail:
21465 return NULL;
21466 }
21467
21468
21469 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21470 PyObject *resultobj = 0;
21471 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21472 int result;
21473 void *argp1 = 0 ;
21474 int res1 = 0 ;
21475 PyObject *swig_obj[1] ;
21476
21477 if (!args) SWIG_fail;
21478 swig_obj[0] = args;
21479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21480 if (!SWIG_IsOK(res1)) {
21481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21482 }
21483 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21484 result = (int) ((arg1)->m_wheelDelta);
21485 resultobj = SWIG_From_int(static_cast< int >(result));
21486 return resultobj;
21487 fail:
21488 return NULL;
21489 }
21490
21491
21492 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21493 PyObject *resultobj = 0;
21494 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21495 int arg2 ;
21496 void *argp1 = 0 ;
21497 int res1 = 0 ;
21498 int val2 ;
21499 int ecode2 = 0 ;
21500 PyObject *swig_obj[2] ;
21501
21502 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21504 if (!SWIG_IsOK(res1)) {
21505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21506 }
21507 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21508 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21509 if (!SWIG_IsOK(ecode2)) {
21510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21511 }
21512 arg2 = static_cast< int >(val2);
21513 if (arg1) (arg1)->m_linesPerAction = arg2;
21514
21515 resultobj = SWIG_Py_Void();
21516 return resultobj;
21517 fail:
21518 return NULL;
21519 }
21520
21521
21522 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21523 PyObject *resultobj = 0;
21524 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21525 int result;
21526 void *argp1 = 0 ;
21527 int res1 = 0 ;
21528 PyObject *swig_obj[1] ;
21529
21530 if (!args) SWIG_fail;
21531 swig_obj[0] = args;
21532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21533 if (!SWIG_IsOK(res1)) {
21534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21535 }
21536 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21537 result = (int) ((arg1)->m_linesPerAction);
21538 resultobj = SWIG_From_int(static_cast< int >(result));
21539 return resultobj;
21540 fail:
21541 return NULL;
21542 }
21543
21544
21545 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21546 PyObject *obj;
21547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21548 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21549 return SWIG_Py_Void();
21550 }
21551
21552 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21553 return SWIG_Python_InitShadowInstance(args);
21554 }
21555
21556 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21557 PyObject *resultobj = 0;
21558 int arg1 = (int) 0 ;
21559 int arg2 = (int) 0 ;
21560 wxSetCursorEvent *result = 0 ;
21561 int val1 ;
21562 int ecode1 = 0 ;
21563 int val2 ;
21564 int ecode2 = 0 ;
21565 PyObject * obj0 = 0 ;
21566 PyObject * obj1 = 0 ;
21567 char * kwnames[] = {
21568 (char *) "x",(char *) "y", NULL
21569 };
21570
21571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21572 if (obj0) {
21573 ecode1 = SWIG_AsVal_int(obj0, &val1);
21574 if (!SWIG_IsOK(ecode1)) {
21575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21576 }
21577 arg1 = static_cast< int >(val1);
21578 }
21579 if (obj1) {
21580 ecode2 = SWIG_AsVal_int(obj1, &val2);
21581 if (!SWIG_IsOK(ecode2)) {
21582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21583 }
21584 arg2 = static_cast< int >(val2);
21585 }
21586 {
21587 PyThreadState* __tstate = wxPyBeginAllowThreads();
21588 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21589 wxPyEndAllowThreads(__tstate);
21590 if (PyErr_Occurred()) SWIG_fail;
21591 }
21592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21593 return resultobj;
21594 fail:
21595 return NULL;
21596 }
21597
21598
21599 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21600 PyObject *resultobj = 0;
21601 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21602 int result;
21603 void *argp1 = 0 ;
21604 int res1 = 0 ;
21605 PyObject *swig_obj[1] ;
21606
21607 if (!args) SWIG_fail;
21608 swig_obj[0] = args;
21609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21610 if (!SWIG_IsOK(res1)) {
21611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21612 }
21613 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21614 {
21615 PyThreadState* __tstate = wxPyBeginAllowThreads();
21616 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21617 wxPyEndAllowThreads(__tstate);
21618 if (PyErr_Occurred()) SWIG_fail;
21619 }
21620 resultobj = SWIG_From_int(static_cast< int >(result));
21621 return resultobj;
21622 fail:
21623 return NULL;
21624 }
21625
21626
21627 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21628 PyObject *resultobj = 0;
21629 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21630 int result;
21631 void *argp1 = 0 ;
21632 int res1 = 0 ;
21633 PyObject *swig_obj[1] ;
21634
21635 if (!args) SWIG_fail;
21636 swig_obj[0] = args;
21637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21638 if (!SWIG_IsOK(res1)) {
21639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21640 }
21641 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21642 {
21643 PyThreadState* __tstate = wxPyBeginAllowThreads();
21644 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21645 wxPyEndAllowThreads(__tstate);
21646 if (PyErr_Occurred()) SWIG_fail;
21647 }
21648 resultobj = SWIG_From_int(static_cast< int >(result));
21649 return resultobj;
21650 fail:
21651 return NULL;
21652 }
21653
21654
21655 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21656 PyObject *resultobj = 0;
21657 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21658 wxCursor *arg2 = 0 ;
21659 void *argp1 = 0 ;
21660 int res1 = 0 ;
21661 void *argp2 = 0 ;
21662 int res2 = 0 ;
21663 PyObject * obj0 = 0 ;
21664 PyObject * obj1 = 0 ;
21665 char * kwnames[] = {
21666 (char *) "self",(char *) "cursor", NULL
21667 };
21668
21669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21671 if (!SWIG_IsOK(res1)) {
21672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21673 }
21674 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21675 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21676 if (!SWIG_IsOK(res2)) {
21677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21678 }
21679 if (!argp2) {
21680 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21681 }
21682 arg2 = reinterpret_cast< wxCursor * >(argp2);
21683 {
21684 PyThreadState* __tstate = wxPyBeginAllowThreads();
21685 (arg1)->SetCursor((wxCursor const &)*arg2);
21686 wxPyEndAllowThreads(__tstate);
21687 if (PyErr_Occurred()) SWIG_fail;
21688 }
21689 resultobj = SWIG_Py_Void();
21690 return resultobj;
21691 fail:
21692 return NULL;
21693 }
21694
21695
21696 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21697 PyObject *resultobj = 0;
21698 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21699 wxCursor *result = 0 ;
21700 void *argp1 = 0 ;
21701 int res1 = 0 ;
21702 PyObject *swig_obj[1] ;
21703
21704 if (!args) SWIG_fail;
21705 swig_obj[0] = args;
21706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21707 if (!SWIG_IsOK(res1)) {
21708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21709 }
21710 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21711 {
21712 PyThreadState* __tstate = wxPyBeginAllowThreads();
21713 {
21714 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21715 result = (wxCursor *) &_result_ref;
21716 }
21717 wxPyEndAllowThreads(__tstate);
21718 if (PyErr_Occurred()) SWIG_fail;
21719 }
21720 {
21721 wxCursor* resultptr = new wxCursor(*result);
21722 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21723 }
21724 return resultobj;
21725 fail:
21726 return NULL;
21727 }
21728
21729
21730 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21731 PyObject *resultobj = 0;
21732 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21733 bool result;
21734 void *argp1 = 0 ;
21735 int res1 = 0 ;
21736 PyObject *swig_obj[1] ;
21737
21738 if (!args) SWIG_fail;
21739 swig_obj[0] = args;
21740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21741 if (!SWIG_IsOK(res1)) {
21742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21743 }
21744 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21745 {
21746 PyThreadState* __tstate = wxPyBeginAllowThreads();
21747 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21748 wxPyEndAllowThreads(__tstate);
21749 if (PyErr_Occurred()) SWIG_fail;
21750 }
21751 {
21752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21753 }
21754 return resultobj;
21755 fail:
21756 return NULL;
21757 }
21758
21759
21760 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21761 PyObject *obj;
21762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21763 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21764 return SWIG_Py_Void();
21765 }
21766
21767 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21768 return SWIG_Python_InitShadowInstance(args);
21769 }
21770
21771 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21772 PyObject *resultobj = 0;
21773 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21774 wxKeyEvent *result = 0 ;
21775 int val1 ;
21776 int ecode1 = 0 ;
21777 PyObject * obj0 = 0 ;
21778 char * kwnames[] = {
21779 (char *) "eventType", NULL
21780 };
21781
21782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21783 if (obj0) {
21784 ecode1 = SWIG_AsVal_int(obj0, &val1);
21785 if (!SWIG_IsOK(ecode1)) {
21786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21787 }
21788 arg1 = static_cast< wxEventType >(val1);
21789 }
21790 {
21791 PyThreadState* __tstate = wxPyBeginAllowThreads();
21792 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21793 wxPyEndAllowThreads(__tstate);
21794 if (PyErr_Occurred()) SWIG_fail;
21795 }
21796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21797 return resultobj;
21798 fail:
21799 return NULL;
21800 }
21801
21802
21803 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21804 PyObject *resultobj = 0;
21805 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21806 int result;
21807 void *argp1 = 0 ;
21808 int res1 = 0 ;
21809 PyObject *swig_obj[1] ;
21810
21811 if (!args) SWIG_fail;
21812 swig_obj[0] = args;
21813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21814 if (!SWIG_IsOK(res1)) {
21815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21816 }
21817 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21818 {
21819 PyThreadState* __tstate = wxPyBeginAllowThreads();
21820 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21821 wxPyEndAllowThreads(__tstate);
21822 if (PyErr_Occurred()) SWIG_fail;
21823 }
21824 resultobj = SWIG_From_int(static_cast< int >(result));
21825 return resultobj;
21826 fail:
21827 return NULL;
21828 }
21829
21830
21831 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21832 PyObject *resultobj = 0;
21833 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21834 bool result;
21835 void *argp1 = 0 ;
21836 int res1 = 0 ;
21837 PyObject *swig_obj[1] ;
21838
21839 if (!args) SWIG_fail;
21840 swig_obj[0] = args;
21841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21842 if (!SWIG_IsOK(res1)) {
21843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21844 }
21845 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21846 {
21847 PyThreadState* __tstate = wxPyBeginAllowThreads();
21848 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21849 wxPyEndAllowThreads(__tstate);
21850 if (PyErr_Occurred()) SWIG_fail;
21851 }
21852 {
21853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21854 }
21855 return resultobj;
21856 fail:
21857 return NULL;
21858 }
21859
21860
21861 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21862 PyObject *resultobj = 0;
21863 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21864 bool result;
21865 void *argp1 = 0 ;
21866 int res1 = 0 ;
21867 PyObject *swig_obj[1] ;
21868
21869 if (!args) SWIG_fail;
21870 swig_obj[0] = args;
21871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21872 if (!SWIG_IsOK(res1)) {
21873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21874 }
21875 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21876 {
21877 PyThreadState* __tstate = wxPyBeginAllowThreads();
21878 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21879 wxPyEndAllowThreads(__tstate);
21880 if (PyErr_Occurred()) SWIG_fail;
21881 }
21882 {
21883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21884 }
21885 return resultobj;
21886 fail:
21887 return NULL;
21888 }
21889
21890
21891 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21892 PyObject *resultobj = 0;
21893 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21894 bool result;
21895 void *argp1 = 0 ;
21896 int res1 = 0 ;
21897 PyObject *swig_obj[1] ;
21898
21899 if (!args) SWIG_fail;
21900 swig_obj[0] = args;
21901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21902 if (!SWIG_IsOK(res1)) {
21903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21904 }
21905 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21906 {
21907 PyThreadState* __tstate = wxPyBeginAllowThreads();
21908 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21909 wxPyEndAllowThreads(__tstate);
21910 if (PyErr_Occurred()) SWIG_fail;
21911 }
21912 {
21913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21914 }
21915 return resultobj;
21916 fail:
21917 return NULL;
21918 }
21919
21920
21921 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21922 PyObject *resultobj = 0;
21923 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21924 bool result;
21925 void *argp1 = 0 ;
21926 int res1 = 0 ;
21927 PyObject *swig_obj[1] ;
21928
21929 if (!args) SWIG_fail;
21930 swig_obj[0] = args;
21931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21932 if (!SWIG_IsOK(res1)) {
21933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21934 }
21935 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21936 {
21937 PyThreadState* __tstate = wxPyBeginAllowThreads();
21938 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
21939 wxPyEndAllowThreads(__tstate);
21940 if (PyErr_Occurred()) SWIG_fail;
21941 }
21942 {
21943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21944 }
21945 return resultobj;
21946 fail:
21947 return NULL;
21948 }
21949
21950
21951 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21952 PyObject *resultobj = 0;
21953 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21954 bool result;
21955 void *argp1 = 0 ;
21956 int res1 = 0 ;
21957 PyObject *swig_obj[1] ;
21958
21959 if (!args) SWIG_fail;
21960 swig_obj[0] = args;
21961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21962 if (!SWIG_IsOK(res1)) {
21963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21964 }
21965 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21966 {
21967 PyThreadState* __tstate = wxPyBeginAllowThreads();
21968 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
21969 wxPyEndAllowThreads(__tstate);
21970 if (PyErr_Occurred()) SWIG_fail;
21971 }
21972 {
21973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21974 }
21975 return resultobj;
21976 fail:
21977 return NULL;
21978 }
21979
21980
21981 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21982 PyObject *resultobj = 0;
21983 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21984 bool result;
21985 void *argp1 = 0 ;
21986 int res1 = 0 ;
21987 PyObject *swig_obj[1] ;
21988
21989 if (!args) SWIG_fail;
21990 swig_obj[0] = args;
21991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21992 if (!SWIG_IsOK(res1)) {
21993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21994 }
21995 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21996 {
21997 PyThreadState* __tstate = wxPyBeginAllowThreads();
21998 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
21999 wxPyEndAllowThreads(__tstate);
22000 if (PyErr_Occurred()) SWIG_fail;
22001 }
22002 {
22003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22004 }
22005 return resultobj;
22006 fail:
22007 return NULL;
22008 }
22009
22010
22011 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22012 PyObject *resultobj = 0;
22013 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22014 int result;
22015 void *argp1 = 0 ;
22016 int res1 = 0 ;
22017 PyObject *swig_obj[1] ;
22018
22019 if (!args) SWIG_fail;
22020 swig_obj[0] = args;
22021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22022 if (!SWIG_IsOK(res1)) {
22023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22024 }
22025 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22026 {
22027 PyThreadState* __tstate = wxPyBeginAllowThreads();
22028 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 resultobj = SWIG_From_int(static_cast< int >(result));
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22040 PyObject *resultobj = 0;
22041 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22042 int result;
22043 void *argp1 = 0 ;
22044 int res1 = 0 ;
22045 PyObject *swig_obj[1] ;
22046
22047 if (!args) SWIG_fail;
22048 swig_obj[0] = args;
22049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22050 if (!SWIG_IsOK(res1)) {
22051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22052 }
22053 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22054 {
22055 PyThreadState* __tstate = wxPyBeginAllowThreads();
22056 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22057 wxPyEndAllowThreads(__tstate);
22058 if (PyErr_Occurred()) SWIG_fail;
22059 }
22060 resultobj = SWIG_From_int(static_cast< int >(result));
22061 return resultobj;
22062 fail:
22063 return NULL;
22064 }
22065
22066
22067 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22068 PyObject *resultobj = 0;
22069 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22070 unsigned int result;
22071 void *argp1 = 0 ;
22072 int res1 = 0 ;
22073 PyObject *swig_obj[1] ;
22074
22075 if (!args) SWIG_fail;
22076 swig_obj[0] = args;
22077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22078 if (!SWIG_IsOK(res1)) {
22079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22080 }
22081 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22082 {
22083 PyThreadState* __tstate = wxPyBeginAllowThreads();
22084 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22085 wxPyEndAllowThreads(__tstate);
22086 if (PyErr_Occurred()) SWIG_fail;
22087 }
22088 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22089 return resultobj;
22090 fail:
22091 return NULL;
22092 }
22093
22094
22095 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22096 PyObject *resultobj = 0;
22097 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22098 unsigned int result;
22099 void *argp1 = 0 ;
22100 int res1 = 0 ;
22101 PyObject *swig_obj[1] ;
22102
22103 if (!args) SWIG_fail;
22104 swig_obj[0] = args;
22105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22106 if (!SWIG_IsOK(res1)) {
22107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22108 }
22109 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22110 {
22111 PyThreadState* __tstate = wxPyBeginAllowThreads();
22112 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22113 wxPyEndAllowThreads(__tstate);
22114 if (PyErr_Occurred()) SWIG_fail;
22115 }
22116 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22117 return resultobj;
22118 fail:
22119 return NULL;
22120 }
22121
22122
22123 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22124 PyObject *resultobj = 0;
22125 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22126 wxPoint result;
22127 void *argp1 = 0 ;
22128 int res1 = 0 ;
22129 PyObject *swig_obj[1] ;
22130
22131 if (!args) SWIG_fail;
22132 swig_obj[0] = args;
22133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22134 if (!SWIG_IsOK(res1)) {
22135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22136 }
22137 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22138 {
22139 PyThreadState* __tstate = wxPyBeginAllowThreads();
22140 result = (arg1)->GetPosition();
22141 wxPyEndAllowThreads(__tstate);
22142 if (PyErr_Occurred()) SWIG_fail;
22143 }
22144 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22145 return resultobj;
22146 fail:
22147 return NULL;
22148 }
22149
22150
22151 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22152 PyObject *resultobj = 0;
22153 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22154 long *arg2 = (long *) 0 ;
22155 long *arg3 = (long *) 0 ;
22156 void *argp1 = 0 ;
22157 int res1 = 0 ;
22158 long temp2 ;
22159 int res2 = SWIG_TMPOBJ ;
22160 long temp3 ;
22161 int res3 = SWIG_TMPOBJ ;
22162 PyObject *swig_obj[1] ;
22163
22164 arg2 = &temp2;
22165 arg3 = &temp3;
22166 if (!args) SWIG_fail;
22167 swig_obj[0] = args;
22168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22169 if (!SWIG_IsOK(res1)) {
22170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22171 }
22172 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22173 {
22174 PyThreadState* __tstate = wxPyBeginAllowThreads();
22175 (arg1)->GetPosition(arg2,arg3);
22176 wxPyEndAllowThreads(__tstate);
22177 if (PyErr_Occurred()) SWIG_fail;
22178 }
22179 resultobj = SWIG_Py_Void();
22180 if (SWIG_IsTmpObj(res2)) {
22181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22182 } else {
22183 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22184 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22185 }
22186 if (SWIG_IsTmpObj(res3)) {
22187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22188 } else {
22189 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22191 }
22192 return resultobj;
22193 fail:
22194 return NULL;
22195 }
22196
22197
22198 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22199 PyObject *resultobj = 0;
22200 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22201 int result;
22202 void *argp1 = 0 ;
22203 int res1 = 0 ;
22204 PyObject *swig_obj[1] ;
22205
22206 if (!args) SWIG_fail;
22207 swig_obj[0] = args;
22208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22209 if (!SWIG_IsOK(res1)) {
22210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22211 }
22212 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22213 {
22214 PyThreadState* __tstate = wxPyBeginAllowThreads();
22215 result = (int)((wxKeyEvent const *)arg1)->GetX();
22216 wxPyEndAllowThreads(__tstate);
22217 if (PyErr_Occurred()) SWIG_fail;
22218 }
22219 resultobj = SWIG_From_int(static_cast< int >(result));
22220 return resultobj;
22221 fail:
22222 return NULL;
22223 }
22224
22225
22226 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22227 PyObject *resultobj = 0;
22228 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22229 int result;
22230 void *argp1 = 0 ;
22231 int res1 = 0 ;
22232 PyObject *swig_obj[1] ;
22233
22234 if (!args) SWIG_fail;
22235 swig_obj[0] = args;
22236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22237 if (!SWIG_IsOK(res1)) {
22238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22239 }
22240 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22241 {
22242 PyThreadState* __tstate = wxPyBeginAllowThreads();
22243 result = (int)((wxKeyEvent const *)arg1)->GetY();
22244 wxPyEndAllowThreads(__tstate);
22245 if (PyErr_Occurred()) SWIG_fail;
22246 }
22247 resultobj = SWIG_From_int(static_cast< int >(result));
22248 return resultobj;
22249 fail:
22250 return NULL;
22251 }
22252
22253
22254 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22255 PyObject *resultobj = 0;
22256 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22257 int arg2 ;
22258 void *argp1 = 0 ;
22259 int res1 = 0 ;
22260 int val2 ;
22261 int ecode2 = 0 ;
22262 PyObject *swig_obj[2] ;
22263
22264 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22266 if (!SWIG_IsOK(res1)) {
22267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22268 }
22269 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22270 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22271 if (!SWIG_IsOK(ecode2)) {
22272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22273 }
22274 arg2 = static_cast< int >(val2);
22275 if (arg1) (arg1)->m_x = arg2;
22276
22277 resultobj = SWIG_Py_Void();
22278 return resultobj;
22279 fail:
22280 return NULL;
22281 }
22282
22283
22284 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22285 PyObject *resultobj = 0;
22286 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22287 int result;
22288 void *argp1 = 0 ;
22289 int res1 = 0 ;
22290 PyObject *swig_obj[1] ;
22291
22292 if (!args) SWIG_fail;
22293 swig_obj[0] = args;
22294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22295 if (!SWIG_IsOK(res1)) {
22296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22297 }
22298 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22299 result = (int) ((arg1)->m_x);
22300 resultobj = SWIG_From_int(static_cast< int >(result));
22301 return resultobj;
22302 fail:
22303 return NULL;
22304 }
22305
22306
22307 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22308 PyObject *resultobj = 0;
22309 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22310 int arg2 ;
22311 void *argp1 = 0 ;
22312 int res1 = 0 ;
22313 int val2 ;
22314 int ecode2 = 0 ;
22315 PyObject *swig_obj[2] ;
22316
22317 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22319 if (!SWIG_IsOK(res1)) {
22320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22321 }
22322 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22323 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22324 if (!SWIG_IsOK(ecode2)) {
22325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22326 }
22327 arg2 = static_cast< int >(val2);
22328 if (arg1) (arg1)->m_y = arg2;
22329
22330 resultobj = SWIG_Py_Void();
22331 return resultobj;
22332 fail:
22333 return NULL;
22334 }
22335
22336
22337 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22338 PyObject *resultobj = 0;
22339 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22340 int result;
22341 void *argp1 = 0 ;
22342 int res1 = 0 ;
22343 PyObject *swig_obj[1] ;
22344
22345 if (!args) SWIG_fail;
22346 swig_obj[0] = args;
22347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22348 if (!SWIG_IsOK(res1)) {
22349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22350 }
22351 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22352 result = (int) ((arg1)->m_y);
22353 resultobj = SWIG_From_int(static_cast< int >(result));
22354 return resultobj;
22355 fail:
22356 return NULL;
22357 }
22358
22359
22360 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22361 PyObject *resultobj = 0;
22362 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22363 long arg2 ;
22364 void *argp1 = 0 ;
22365 int res1 = 0 ;
22366 long val2 ;
22367 int ecode2 = 0 ;
22368 PyObject *swig_obj[2] ;
22369
22370 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22372 if (!SWIG_IsOK(res1)) {
22373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22374 }
22375 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22376 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22377 if (!SWIG_IsOK(ecode2)) {
22378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22379 }
22380 arg2 = static_cast< long >(val2);
22381 if (arg1) (arg1)->m_keyCode = arg2;
22382
22383 resultobj = SWIG_Py_Void();
22384 return resultobj;
22385 fail:
22386 return NULL;
22387 }
22388
22389
22390 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22391 PyObject *resultobj = 0;
22392 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22393 long result;
22394 void *argp1 = 0 ;
22395 int res1 = 0 ;
22396 PyObject *swig_obj[1] ;
22397
22398 if (!args) SWIG_fail;
22399 swig_obj[0] = args;
22400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22401 if (!SWIG_IsOK(res1)) {
22402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22403 }
22404 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22405 result = (long) ((arg1)->m_keyCode);
22406 resultobj = SWIG_From_long(static_cast< long >(result));
22407 return resultobj;
22408 fail:
22409 return NULL;
22410 }
22411
22412
22413 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22414 PyObject *resultobj = 0;
22415 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22416 bool arg2 ;
22417 void *argp1 = 0 ;
22418 int res1 = 0 ;
22419 bool val2 ;
22420 int ecode2 = 0 ;
22421 PyObject *swig_obj[2] ;
22422
22423 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22425 if (!SWIG_IsOK(res1)) {
22426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22427 }
22428 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22429 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22430 if (!SWIG_IsOK(ecode2)) {
22431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22432 }
22433 arg2 = static_cast< bool >(val2);
22434 if (arg1) (arg1)->m_controlDown = arg2;
22435
22436 resultobj = SWIG_Py_Void();
22437 return resultobj;
22438 fail:
22439 return NULL;
22440 }
22441
22442
22443 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22444 PyObject *resultobj = 0;
22445 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22446 bool result;
22447 void *argp1 = 0 ;
22448 int res1 = 0 ;
22449 PyObject *swig_obj[1] ;
22450
22451 if (!args) SWIG_fail;
22452 swig_obj[0] = args;
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_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22456 }
22457 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22458 result = (bool) ((arg1)->m_controlDown);
22459 {
22460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22461 }
22462 return resultobj;
22463 fail:
22464 return NULL;
22465 }
22466
22467
22468 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22469 PyObject *resultobj = 0;
22470 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22471 bool arg2 ;
22472 void *argp1 = 0 ;
22473 int res1 = 0 ;
22474 bool val2 ;
22475 int ecode2 = 0 ;
22476 PyObject *swig_obj[2] ;
22477
22478 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22480 if (!SWIG_IsOK(res1)) {
22481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22482 }
22483 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22484 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22485 if (!SWIG_IsOK(ecode2)) {
22486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22487 }
22488 arg2 = static_cast< bool >(val2);
22489 if (arg1) (arg1)->m_shiftDown = arg2;
22490
22491 resultobj = SWIG_Py_Void();
22492 return resultobj;
22493 fail:
22494 return NULL;
22495 }
22496
22497
22498 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22499 PyObject *resultobj = 0;
22500 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22501 bool result;
22502 void *argp1 = 0 ;
22503 int res1 = 0 ;
22504 PyObject *swig_obj[1] ;
22505
22506 if (!args) SWIG_fail;
22507 swig_obj[0] = args;
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_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22511 }
22512 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22513 result = (bool) ((arg1)->m_shiftDown);
22514 {
22515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22516 }
22517 return resultobj;
22518 fail:
22519 return NULL;
22520 }
22521
22522
22523 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22524 PyObject *resultobj = 0;
22525 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22526 bool arg2 ;
22527 void *argp1 = 0 ;
22528 int res1 = 0 ;
22529 bool val2 ;
22530 int ecode2 = 0 ;
22531 PyObject *swig_obj[2] ;
22532
22533 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22535 if (!SWIG_IsOK(res1)) {
22536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22537 }
22538 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22539 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22540 if (!SWIG_IsOK(ecode2)) {
22541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22542 }
22543 arg2 = static_cast< bool >(val2);
22544 if (arg1) (arg1)->m_altDown = arg2;
22545
22546 resultobj = SWIG_Py_Void();
22547 return resultobj;
22548 fail:
22549 return NULL;
22550 }
22551
22552
22553 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22554 PyObject *resultobj = 0;
22555 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22556 bool result;
22557 void *argp1 = 0 ;
22558 int res1 = 0 ;
22559 PyObject *swig_obj[1] ;
22560
22561 if (!args) SWIG_fail;
22562 swig_obj[0] = args;
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_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22566 }
22567 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22568 result = (bool) ((arg1)->m_altDown);
22569 {
22570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22571 }
22572 return resultobj;
22573 fail:
22574 return NULL;
22575 }
22576
22577
22578 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22579 PyObject *resultobj = 0;
22580 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22581 bool arg2 ;
22582 void *argp1 = 0 ;
22583 int res1 = 0 ;
22584 bool val2 ;
22585 int ecode2 = 0 ;
22586 PyObject *swig_obj[2] ;
22587
22588 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22590 if (!SWIG_IsOK(res1)) {
22591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22592 }
22593 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22594 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22595 if (!SWIG_IsOK(ecode2)) {
22596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22597 }
22598 arg2 = static_cast< bool >(val2);
22599 if (arg1) (arg1)->m_metaDown = arg2;
22600
22601 resultobj = SWIG_Py_Void();
22602 return resultobj;
22603 fail:
22604 return NULL;
22605 }
22606
22607
22608 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22609 PyObject *resultobj = 0;
22610 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22611 bool result;
22612 void *argp1 = 0 ;
22613 int res1 = 0 ;
22614 PyObject *swig_obj[1] ;
22615
22616 if (!args) SWIG_fail;
22617 swig_obj[0] = args;
22618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22619 if (!SWIG_IsOK(res1)) {
22620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22621 }
22622 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22623 result = (bool) ((arg1)->m_metaDown);
22624 {
22625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22626 }
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22634 PyObject *resultobj = 0;
22635 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22636 bool arg2 ;
22637 void *argp1 = 0 ;
22638 int res1 = 0 ;
22639 bool val2 ;
22640 int ecode2 = 0 ;
22641 PyObject *swig_obj[2] ;
22642
22643 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22645 if (!SWIG_IsOK(res1)) {
22646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22647 }
22648 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22649 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22650 if (!SWIG_IsOK(ecode2)) {
22651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22652 }
22653 arg2 = static_cast< bool >(val2);
22654 if (arg1) (arg1)->m_scanCode = arg2;
22655
22656 resultobj = SWIG_Py_Void();
22657 return resultobj;
22658 fail:
22659 return NULL;
22660 }
22661
22662
22663 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22664 PyObject *resultobj = 0;
22665 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22666 bool result;
22667 void *argp1 = 0 ;
22668 int res1 = 0 ;
22669 PyObject *swig_obj[1] ;
22670
22671 if (!args) SWIG_fail;
22672 swig_obj[0] = args;
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_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22676 }
22677 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22678 result = (bool) ((arg1)->m_scanCode);
22679 {
22680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22681 }
22682 return resultobj;
22683 fail:
22684 return NULL;
22685 }
22686
22687
22688 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22689 PyObject *resultobj = 0;
22690 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22691 unsigned int arg2 ;
22692 void *argp1 = 0 ;
22693 int res1 = 0 ;
22694 unsigned int val2 ;
22695 int ecode2 = 0 ;
22696 PyObject *swig_obj[2] ;
22697
22698 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22700 if (!SWIG_IsOK(res1)) {
22701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22702 }
22703 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22704 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22705 if (!SWIG_IsOK(ecode2)) {
22706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22707 }
22708 arg2 = static_cast< unsigned int >(val2);
22709 if (arg1) (arg1)->m_rawCode = arg2;
22710
22711 resultobj = SWIG_Py_Void();
22712 return resultobj;
22713 fail:
22714 return NULL;
22715 }
22716
22717
22718 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22719 PyObject *resultobj = 0;
22720 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22721 unsigned int result;
22722 void *argp1 = 0 ;
22723 int res1 = 0 ;
22724 PyObject *swig_obj[1] ;
22725
22726 if (!args) SWIG_fail;
22727 swig_obj[0] = args;
22728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22729 if (!SWIG_IsOK(res1)) {
22730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22731 }
22732 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22733 result = (unsigned int) ((arg1)->m_rawCode);
22734 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22735 return resultobj;
22736 fail:
22737 return NULL;
22738 }
22739
22740
22741 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22742 PyObject *resultobj = 0;
22743 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22744 unsigned int arg2 ;
22745 void *argp1 = 0 ;
22746 int res1 = 0 ;
22747 unsigned int val2 ;
22748 int ecode2 = 0 ;
22749 PyObject *swig_obj[2] ;
22750
22751 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22753 if (!SWIG_IsOK(res1)) {
22754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22755 }
22756 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22757 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22758 if (!SWIG_IsOK(ecode2)) {
22759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22760 }
22761 arg2 = static_cast< unsigned int >(val2);
22762 if (arg1) (arg1)->m_rawFlags = arg2;
22763
22764 resultobj = SWIG_Py_Void();
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22772 PyObject *resultobj = 0;
22773 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22774 unsigned int result;
22775 void *argp1 = 0 ;
22776 int res1 = 0 ;
22777 PyObject *swig_obj[1] ;
22778
22779 if (!args) SWIG_fail;
22780 swig_obj[0] = args;
22781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22782 if (!SWIG_IsOK(res1)) {
22783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22784 }
22785 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22786 result = (unsigned int) ((arg1)->m_rawFlags);
22787 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22788 return resultobj;
22789 fail:
22790 return NULL;
22791 }
22792
22793
22794 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22795 PyObject *obj;
22796 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22797 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22798 return SWIG_Py_Void();
22799 }
22800
22801 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22802 return SWIG_Python_InitShadowInstance(args);
22803 }
22804
22805 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22806 PyObject *resultobj = 0;
22807 wxSize const &arg1_defvalue = wxDefaultSize ;
22808 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22809 int arg2 = (int) 0 ;
22810 wxSizeEvent *result = 0 ;
22811 wxSize temp1 ;
22812 int val2 ;
22813 int ecode2 = 0 ;
22814 PyObject * obj0 = 0 ;
22815 PyObject * obj1 = 0 ;
22816 char * kwnames[] = {
22817 (char *) "sz",(char *) "winid", NULL
22818 };
22819
22820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22821 if (obj0) {
22822 {
22823 arg1 = &temp1;
22824 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22825 }
22826 }
22827 if (obj1) {
22828 ecode2 = SWIG_AsVal_int(obj1, &val2);
22829 if (!SWIG_IsOK(ecode2)) {
22830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22831 }
22832 arg2 = static_cast< int >(val2);
22833 }
22834 {
22835 PyThreadState* __tstate = wxPyBeginAllowThreads();
22836 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22837 wxPyEndAllowThreads(__tstate);
22838 if (PyErr_Occurred()) SWIG_fail;
22839 }
22840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22841 return resultobj;
22842 fail:
22843 return NULL;
22844 }
22845
22846
22847 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22848 PyObject *resultobj = 0;
22849 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22850 wxSize result;
22851 void *argp1 = 0 ;
22852 int res1 = 0 ;
22853 PyObject *swig_obj[1] ;
22854
22855 if (!args) SWIG_fail;
22856 swig_obj[0] = args;
22857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22858 if (!SWIG_IsOK(res1)) {
22859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22860 }
22861 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22862 {
22863 PyThreadState* __tstate = wxPyBeginAllowThreads();
22864 result = ((wxSizeEvent const *)arg1)->GetSize();
22865 wxPyEndAllowThreads(__tstate);
22866 if (PyErr_Occurred()) SWIG_fail;
22867 }
22868 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22869 return resultobj;
22870 fail:
22871 return NULL;
22872 }
22873
22874
22875 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22876 PyObject *resultobj = 0;
22877 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22878 wxRect result;
22879 void *argp1 = 0 ;
22880 int res1 = 0 ;
22881 PyObject *swig_obj[1] ;
22882
22883 if (!args) SWIG_fail;
22884 swig_obj[0] = args;
22885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22886 if (!SWIG_IsOK(res1)) {
22887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22888 }
22889 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22890 {
22891 PyThreadState* __tstate = wxPyBeginAllowThreads();
22892 result = ((wxSizeEvent const *)arg1)->GetRect();
22893 wxPyEndAllowThreads(__tstate);
22894 if (PyErr_Occurred()) SWIG_fail;
22895 }
22896 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22897 return resultobj;
22898 fail:
22899 return NULL;
22900 }
22901
22902
22903 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22904 PyObject *resultobj = 0;
22905 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22906 wxRect arg2 ;
22907 void *argp1 = 0 ;
22908 int res1 = 0 ;
22909 void *argp2 ;
22910 int res2 = 0 ;
22911 PyObject * obj0 = 0 ;
22912 PyObject * obj1 = 0 ;
22913 char * kwnames[] = {
22914 (char *) "self",(char *) "rect", NULL
22915 };
22916
22917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22919 if (!SWIG_IsOK(res1)) {
22920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22921 }
22922 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22923 {
22924 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22925 if (!SWIG_IsOK(res2)) {
22926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22927 }
22928 if (!argp2) {
22929 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22930 } else {
22931 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
22932 arg2 = *temp;
22933 if (SWIG_IsNewObj(res2)) delete temp;
22934 }
22935 }
22936 {
22937 PyThreadState* __tstate = wxPyBeginAllowThreads();
22938 (arg1)->SetRect(arg2);
22939 wxPyEndAllowThreads(__tstate);
22940 if (PyErr_Occurred()) SWIG_fail;
22941 }
22942 resultobj = SWIG_Py_Void();
22943 return resultobj;
22944 fail:
22945 return NULL;
22946 }
22947
22948
22949 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22950 PyObject *resultobj = 0;
22951 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22952 wxSize arg2 ;
22953 void *argp1 = 0 ;
22954 int res1 = 0 ;
22955 void *argp2 ;
22956 int res2 = 0 ;
22957 PyObject * obj0 = 0 ;
22958 PyObject * obj1 = 0 ;
22959 char * kwnames[] = {
22960 (char *) "self",(char *) "size", NULL
22961 };
22962
22963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
22964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22965 if (!SWIG_IsOK(res1)) {
22966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22967 }
22968 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22969 {
22970 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
22971 if (!SWIG_IsOK(res2)) {
22972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22973 }
22974 if (!argp2) {
22975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22976 } else {
22977 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
22978 arg2 = *temp;
22979 if (SWIG_IsNewObj(res2)) delete temp;
22980 }
22981 }
22982 {
22983 PyThreadState* __tstate = wxPyBeginAllowThreads();
22984 wxSizeEvent_SetSize(arg1,arg2);
22985 wxPyEndAllowThreads(__tstate);
22986 if (PyErr_Occurred()) SWIG_fail;
22987 }
22988 resultobj = SWIG_Py_Void();
22989 return resultobj;
22990 fail:
22991 return NULL;
22992 }
22993
22994
22995 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22996 PyObject *resultobj = 0;
22997 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22998 wxSize *arg2 = (wxSize *) 0 ;
22999 void *argp1 = 0 ;
23000 int res1 = 0 ;
23001 void *argp2 = 0 ;
23002 int res2 = 0 ;
23003 PyObject *swig_obj[2] ;
23004
23005 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23007 if (!SWIG_IsOK(res1)) {
23008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23009 }
23010 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23011 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23012 if (!SWIG_IsOK(res2)) {
23013 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23014 }
23015 arg2 = reinterpret_cast< wxSize * >(argp2);
23016 if (arg1) (arg1)->m_size = *arg2;
23017
23018 resultobj = SWIG_Py_Void();
23019 return resultobj;
23020 fail:
23021 return NULL;
23022 }
23023
23024
23025 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23026 PyObject *resultobj = 0;
23027 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23028 wxSize *result = 0 ;
23029 void *argp1 = 0 ;
23030 int res1 = 0 ;
23031 PyObject *swig_obj[1] ;
23032
23033 if (!args) SWIG_fail;
23034 swig_obj[0] = args;
23035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23036 if (!SWIG_IsOK(res1)) {
23037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23038 }
23039 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23040 result = (wxSize *)& ((arg1)->m_size);
23041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23042 return resultobj;
23043 fail:
23044 return NULL;
23045 }
23046
23047
23048 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23049 PyObject *resultobj = 0;
23050 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23051 wxRect *arg2 = (wxRect *) 0 ;
23052 void *argp1 = 0 ;
23053 int res1 = 0 ;
23054 void *argp2 = 0 ;
23055 int res2 = 0 ;
23056 PyObject *swig_obj[2] ;
23057
23058 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23060 if (!SWIG_IsOK(res1)) {
23061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23062 }
23063 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23064 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23065 if (!SWIG_IsOK(res2)) {
23066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23067 }
23068 arg2 = reinterpret_cast< wxRect * >(argp2);
23069 if (arg1) (arg1)->m_rect = *arg2;
23070
23071 resultobj = SWIG_Py_Void();
23072 return resultobj;
23073 fail:
23074 return NULL;
23075 }
23076
23077
23078 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23079 PyObject *resultobj = 0;
23080 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23081 wxRect *result = 0 ;
23082 void *argp1 = 0 ;
23083 int res1 = 0 ;
23084 PyObject *swig_obj[1] ;
23085
23086 if (!args) SWIG_fail;
23087 swig_obj[0] = args;
23088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23089 if (!SWIG_IsOK(res1)) {
23090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23091 }
23092 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23093 result = (wxRect *)& ((arg1)->m_rect);
23094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23095 return resultobj;
23096 fail:
23097 return NULL;
23098 }
23099
23100
23101 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23102 PyObject *obj;
23103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23104 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23105 return SWIG_Py_Void();
23106 }
23107
23108 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23109 return SWIG_Python_InitShadowInstance(args);
23110 }
23111
23112 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23113 PyObject *resultobj = 0;
23114 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23115 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23116 int arg2 = (int) 0 ;
23117 wxMoveEvent *result = 0 ;
23118 wxPoint temp1 ;
23119 int val2 ;
23120 int ecode2 = 0 ;
23121 PyObject * obj0 = 0 ;
23122 PyObject * obj1 = 0 ;
23123 char * kwnames[] = {
23124 (char *) "pos",(char *) "winid", NULL
23125 };
23126
23127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23128 if (obj0) {
23129 {
23130 arg1 = &temp1;
23131 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23132 }
23133 }
23134 if (obj1) {
23135 ecode2 = SWIG_AsVal_int(obj1, &val2);
23136 if (!SWIG_IsOK(ecode2)) {
23137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23138 }
23139 arg2 = static_cast< int >(val2);
23140 }
23141 {
23142 PyThreadState* __tstate = wxPyBeginAllowThreads();
23143 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23144 wxPyEndAllowThreads(__tstate);
23145 if (PyErr_Occurred()) SWIG_fail;
23146 }
23147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23148 return resultobj;
23149 fail:
23150 return NULL;
23151 }
23152
23153
23154 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23155 PyObject *resultobj = 0;
23156 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23157 wxPoint result;
23158 void *argp1 = 0 ;
23159 int res1 = 0 ;
23160 PyObject *swig_obj[1] ;
23161
23162 if (!args) SWIG_fail;
23163 swig_obj[0] = args;
23164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23165 if (!SWIG_IsOK(res1)) {
23166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23167 }
23168 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23169 {
23170 PyThreadState* __tstate = wxPyBeginAllowThreads();
23171 result = ((wxMoveEvent const *)arg1)->GetPosition();
23172 wxPyEndAllowThreads(__tstate);
23173 if (PyErr_Occurred()) SWIG_fail;
23174 }
23175 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23176 return resultobj;
23177 fail:
23178 return NULL;
23179 }
23180
23181
23182 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23183 PyObject *resultobj = 0;
23184 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23185 wxRect result;
23186 void *argp1 = 0 ;
23187 int res1 = 0 ;
23188 PyObject *swig_obj[1] ;
23189
23190 if (!args) SWIG_fail;
23191 swig_obj[0] = args;
23192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23193 if (!SWIG_IsOK(res1)) {
23194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23195 }
23196 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23197 {
23198 PyThreadState* __tstate = wxPyBeginAllowThreads();
23199 result = ((wxMoveEvent const *)arg1)->GetRect();
23200 wxPyEndAllowThreads(__tstate);
23201 if (PyErr_Occurred()) SWIG_fail;
23202 }
23203 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23204 return resultobj;
23205 fail:
23206 return NULL;
23207 }
23208
23209
23210 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23211 PyObject *resultobj = 0;
23212 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23213 wxRect *arg2 = 0 ;
23214 void *argp1 = 0 ;
23215 int res1 = 0 ;
23216 wxRect temp2 ;
23217 PyObject * obj0 = 0 ;
23218 PyObject * obj1 = 0 ;
23219 char * kwnames[] = {
23220 (char *) "self",(char *) "rect", NULL
23221 };
23222
23223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23225 if (!SWIG_IsOK(res1)) {
23226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23227 }
23228 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23229 {
23230 arg2 = &temp2;
23231 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23232 }
23233 {
23234 PyThreadState* __tstate = wxPyBeginAllowThreads();
23235 (arg1)->SetRect((wxRect const &)*arg2);
23236 wxPyEndAllowThreads(__tstate);
23237 if (PyErr_Occurred()) SWIG_fail;
23238 }
23239 resultobj = SWIG_Py_Void();
23240 return resultobj;
23241 fail:
23242 return NULL;
23243 }
23244
23245
23246 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23247 PyObject *resultobj = 0;
23248 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23249 wxPoint *arg2 = 0 ;
23250 void *argp1 = 0 ;
23251 int res1 = 0 ;
23252 wxPoint temp2 ;
23253 PyObject * obj0 = 0 ;
23254 PyObject * obj1 = 0 ;
23255 char * kwnames[] = {
23256 (char *) "self",(char *) "pos", NULL
23257 };
23258
23259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23261 if (!SWIG_IsOK(res1)) {
23262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23263 }
23264 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23265 {
23266 arg2 = &temp2;
23267 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23268 }
23269 {
23270 PyThreadState* __tstate = wxPyBeginAllowThreads();
23271 (arg1)->SetPosition((wxPoint const &)*arg2);
23272 wxPyEndAllowThreads(__tstate);
23273 if (PyErr_Occurred()) SWIG_fail;
23274 }
23275 resultobj = SWIG_Py_Void();
23276 return resultobj;
23277 fail:
23278 return NULL;
23279 }
23280
23281
23282 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23283 PyObject *obj;
23284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23285 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23286 return SWIG_Py_Void();
23287 }
23288
23289 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23290 return SWIG_Python_InitShadowInstance(args);
23291 }
23292
23293 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23294 PyObject *resultobj = 0;
23295 int arg1 = (int) 0 ;
23296 wxPaintEvent *result = 0 ;
23297 int val1 ;
23298 int ecode1 = 0 ;
23299 PyObject * obj0 = 0 ;
23300 char * kwnames[] = {
23301 (char *) "Id", NULL
23302 };
23303
23304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23305 if (obj0) {
23306 ecode1 = SWIG_AsVal_int(obj0, &val1);
23307 if (!SWIG_IsOK(ecode1)) {
23308 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23309 }
23310 arg1 = static_cast< int >(val1);
23311 }
23312 {
23313 PyThreadState* __tstate = wxPyBeginAllowThreads();
23314 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23315 wxPyEndAllowThreads(__tstate);
23316 if (PyErr_Occurred()) SWIG_fail;
23317 }
23318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23319 return resultobj;
23320 fail:
23321 return NULL;
23322 }
23323
23324
23325 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23326 PyObject *obj;
23327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23328 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23329 return SWIG_Py_Void();
23330 }
23331
23332 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23333 return SWIG_Python_InitShadowInstance(args);
23334 }
23335
23336 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23337 PyObject *resultobj = 0;
23338 int arg1 = (int) 0 ;
23339 wxNcPaintEvent *result = 0 ;
23340 int val1 ;
23341 int ecode1 = 0 ;
23342 PyObject * obj0 = 0 ;
23343 char * kwnames[] = {
23344 (char *) "winid", NULL
23345 };
23346
23347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23348 if (obj0) {
23349 ecode1 = SWIG_AsVal_int(obj0, &val1);
23350 if (!SWIG_IsOK(ecode1)) {
23351 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23352 }
23353 arg1 = static_cast< int >(val1);
23354 }
23355 {
23356 PyThreadState* __tstate = wxPyBeginAllowThreads();
23357 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23358 wxPyEndAllowThreads(__tstate);
23359 if (PyErr_Occurred()) SWIG_fail;
23360 }
23361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23362 return resultobj;
23363 fail:
23364 return NULL;
23365 }
23366
23367
23368 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23369 PyObject *obj;
23370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23371 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23372 return SWIG_Py_Void();
23373 }
23374
23375 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23376 return SWIG_Python_InitShadowInstance(args);
23377 }
23378
23379 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23380 PyObject *resultobj = 0;
23381 int arg1 = (int) 0 ;
23382 wxDC *arg2 = (wxDC *) NULL ;
23383 wxEraseEvent *result = 0 ;
23384 int val1 ;
23385 int ecode1 = 0 ;
23386 void *argp2 = 0 ;
23387 int res2 = 0 ;
23388 PyObject * obj0 = 0 ;
23389 PyObject * obj1 = 0 ;
23390 char * kwnames[] = {
23391 (char *) "Id",(char *) "dc", NULL
23392 };
23393
23394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23395 if (obj0) {
23396 ecode1 = SWIG_AsVal_int(obj0, &val1);
23397 if (!SWIG_IsOK(ecode1)) {
23398 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23399 }
23400 arg1 = static_cast< int >(val1);
23401 }
23402 if (obj1) {
23403 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23404 if (!SWIG_IsOK(res2)) {
23405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23406 }
23407 arg2 = reinterpret_cast< wxDC * >(argp2);
23408 }
23409 {
23410 PyThreadState* __tstate = wxPyBeginAllowThreads();
23411 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23412 wxPyEndAllowThreads(__tstate);
23413 if (PyErr_Occurred()) SWIG_fail;
23414 }
23415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23416 return resultobj;
23417 fail:
23418 return NULL;
23419 }
23420
23421
23422 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23423 PyObject *resultobj = 0;
23424 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23425 wxDC *result = 0 ;
23426 void *argp1 = 0 ;
23427 int res1 = 0 ;
23428 PyObject *swig_obj[1] ;
23429
23430 if (!args) SWIG_fail;
23431 swig_obj[0] = args;
23432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23433 if (!SWIG_IsOK(res1)) {
23434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23435 }
23436 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23437 {
23438 PyThreadState* __tstate = wxPyBeginAllowThreads();
23439 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23440 wxPyEndAllowThreads(__tstate);
23441 if (PyErr_Occurred()) SWIG_fail;
23442 }
23443 {
23444 resultobj = wxPyMake_wxObject(result, (bool)0);
23445 }
23446 return resultobj;
23447 fail:
23448 return NULL;
23449 }
23450
23451
23452 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23453 PyObject *obj;
23454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23455 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23456 return SWIG_Py_Void();
23457 }
23458
23459 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23460 return SWIG_Python_InitShadowInstance(args);
23461 }
23462
23463 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23464 PyObject *resultobj = 0;
23465 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23466 int arg2 = (int) 0 ;
23467 wxFocusEvent *result = 0 ;
23468 int val1 ;
23469 int ecode1 = 0 ;
23470 int val2 ;
23471 int ecode2 = 0 ;
23472 PyObject * obj0 = 0 ;
23473 PyObject * obj1 = 0 ;
23474 char * kwnames[] = {
23475 (char *) "type",(char *) "winid", NULL
23476 };
23477
23478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23479 if (obj0) {
23480 ecode1 = SWIG_AsVal_int(obj0, &val1);
23481 if (!SWIG_IsOK(ecode1)) {
23482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23483 }
23484 arg1 = static_cast< wxEventType >(val1);
23485 }
23486 if (obj1) {
23487 ecode2 = SWIG_AsVal_int(obj1, &val2);
23488 if (!SWIG_IsOK(ecode2)) {
23489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23490 }
23491 arg2 = static_cast< int >(val2);
23492 }
23493 {
23494 PyThreadState* __tstate = wxPyBeginAllowThreads();
23495 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23496 wxPyEndAllowThreads(__tstate);
23497 if (PyErr_Occurred()) SWIG_fail;
23498 }
23499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23500 return resultobj;
23501 fail:
23502 return NULL;
23503 }
23504
23505
23506 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23507 PyObject *resultobj = 0;
23508 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23509 wxWindow *result = 0 ;
23510 void *argp1 = 0 ;
23511 int res1 = 0 ;
23512 PyObject *swig_obj[1] ;
23513
23514 if (!args) SWIG_fail;
23515 swig_obj[0] = args;
23516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23517 if (!SWIG_IsOK(res1)) {
23518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23519 }
23520 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23521 {
23522 PyThreadState* __tstate = wxPyBeginAllowThreads();
23523 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23524 wxPyEndAllowThreads(__tstate);
23525 if (PyErr_Occurred()) SWIG_fail;
23526 }
23527 {
23528 resultobj = wxPyMake_wxObject(result, (bool)0);
23529 }
23530 return resultobj;
23531 fail:
23532 return NULL;
23533 }
23534
23535
23536 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23537 PyObject *resultobj = 0;
23538 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23539 wxWindow *arg2 = (wxWindow *) 0 ;
23540 void *argp1 = 0 ;
23541 int res1 = 0 ;
23542 void *argp2 = 0 ;
23543 int res2 = 0 ;
23544 PyObject * obj0 = 0 ;
23545 PyObject * obj1 = 0 ;
23546 char * kwnames[] = {
23547 (char *) "self",(char *) "win", NULL
23548 };
23549
23550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23552 if (!SWIG_IsOK(res1)) {
23553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23554 }
23555 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23556 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23557 if (!SWIG_IsOK(res2)) {
23558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23559 }
23560 arg2 = reinterpret_cast< wxWindow * >(argp2);
23561 {
23562 PyThreadState* __tstate = wxPyBeginAllowThreads();
23563 (arg1)->SetWindow(arg2);
23564 wxPyEndAllowThreads(__tstate);
23565 if (PyErr_Occurred()) SWIG_fail;
23566 }
23567 resultobj = SWIG_Py_Void();
23568 return resultobj;
23569 fail:
23570 return NULL;
23571 }
23572
23573
23574 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23575 PyObject *obj;
23576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23577 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23578 return SWIG_Py_Void();
23579 }
23580
23581 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23582 return SWIG_Python_InitShadowInstance(args);
23583 }
23584
23585 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23586 PyObject *resultobj = 0;
23587 wxWindow *arg1 = (wxWindow *) NULL ;
23588 wxChildFocusEvent *result = 0 ;
23589 void *argp1 = 0 ;
23590 int res1 = 0 ;
23591 PyObject * obj0 = 0 ;
23592 char * kwnames[] = {
23593 (char *) "win", NULL
23594 };
23595
23596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23597 if (obj0) {
23598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23599 if (!SWIG_IsOK(res1)) {
23600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23601 }
23602 arg1 = reinterpret_cast< wxWindow * >(argp1);
23603 }
23604 {
23605 PyThreadState* __tstate = wxPyBeginAllowThreads();
23606 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23607 wxPyEndAllowThreads(__tstate);
23608 if (PyErr_Occurred()) SWIG_fail;
23609 }
23610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23618 PyObject *resultobj = 0;
23619 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23620 wxWindow *result = 0 ;
23621 void *argp1 = 0 ;
23622 int res1 = 0 ;
23623 PyObject *swig_obj[1] ;
23624
23625 if (!args) SWIG_fail;
23626 swig_obj[0] = args;
23627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23628 if (!SWIG_IsOK(res1)) {
23629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23630 }
23631 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 {
23639 resultobj = wxPyMake_wxObject(result, (bool)0);
23640 }
23641 return resultobj;
23642 fail:
23643 return NULL;
23644 }
23645
23646
23647 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23648 PyObject *obj;
23649 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23650 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23651 return SWIG_Py_Void();
23652 }
23653
23654 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23655 return SWIG_Python_InitShadowInstance(args);
23656 }
23657
23658 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23659 PyObject *resultobj = 0;
23660 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23661 bool arg2 = (bool) true ;
23662 int arg3 = (int) 0 ;
23663 wxActivateEvent *result = 0 ;
23664 int val1 ;
23665 int ecode1 = 0 ;
23666 bool val2 ;
23667 int ecode2 = 0 ;
23668 int val3 ;
23669 int ecode3 = 0 ;
23670 PyObject * obj0 = 0 ;
23671 PyObject * obj1 = 0 ;
23672 PyObject * obj2 = 0 ;
23673 char * kwnames[] = {
23674 (char *) "type",(char *) "active",(char *) "Id", NULL
23675 };
23676
23677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23678 if (obj0) {
23679 ecode1 = SWIG_AsVal_int(obj0, &val1);
23680 if (!SWIG_IsOK(ecode1)) {
23681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23682 }
23683 arg1 = static_cast< wxEventType >(val1);
23684 }
23685 if (obj1) {
23686 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23687 if (!SWIG_IsOK(ecode2)) {
23688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23689 }
23690 arg2 = static_cast< bool >(val2);
23691 }
23692 if (obj2) {
23693 ecode3 = SWIG_AsVal_int(obj2, &val3);
23694 if (!SWIG_IsOK(ecode3)) {
23695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23696 }
23697 arg3 = static_cast< int >(val3);
23698 }
23699 {
23700 PyThreadState* __tstate = wxPyBeginAllowThreads();
23701 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23702 wxPyEndAllowThreads(__tstate);
23703 if (PyErr_Occurred()) SWIG_fail;
23704 }
23705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23706 return resultobj;
23707 fail:
23708 return NULL;
23709 }
23710
23711
23712 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23713 PyObject *resultobj = 0;
23714 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23715 bool result;
23716 void *argp1 = 0 ;
23717 int res1 = 0 ;
23718 PyObject *swig_obj[1] ;
23719
23720 if (!args) SWIG_fail;
23721 swig_obj[0] = args;
23722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23723 if (!SWIG_IsOK(res1)) {
23724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23725 }
23726 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23727 {
23728 PyThreadState* __tstate = wxPyBeginAllowThreads();
23729 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23730 wxPyEndAllowThreads(__tstate);
23731 if (PyErr_Occurred()) SWIG_fail;
23732 }
23733 {
23734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23735 }
23736 return resultobj;
23737 fail:
23738 return NULL;
23739 }
23740
23741
23742 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23743 PyObject *obj;
23744 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23745 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23746 return SWIG_Py_Void();
23747 }
23748
23749 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23750 return SWIG_Python_InitShadowInstance(args);
23751 }
23752
23753 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23754 PyObject *resultobj = 0;
23755 int arg1 = (int) 0 ;
23756 wxInitDialogEvent *result = 0 ;
23757 int val1 ;
23758 int ecode1 = 0 ;
23759 PyObject * obj0 = 0 ;
23760 char * kwnames[] = {
23761 (char *) "Id", NULL
23762 };
23763
23764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23765 if (obj0) {
23766 ecode1 = SWIG_AsVal_int(obj0, &val1);
23767 if (!SWIG_IsOK(ecode1)) {
23768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23769 }
23770 arg1 = static_cast< int >(val1);
23771 }
23772 {
23773 PyThreadState* __tstate = wxPyBeginAllowThreads();
23774 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23775 wxPyEndAllowThreads(__tstate);
23776 if (PyErr_Occurred()) SWIG_fail;
23777 }
23778 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23779 return resultobj;
23780 fail:
23781 return NULL;
23782 }
23783
23784
23785 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23786 PyObject *obj;
23787 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23788 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23789 return SWIG_Py_Void();
23790 }
23791
23792 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23793 return SWIG_Python_InitShadowInstance(args);
23794 }
23795
23796 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23797 PyObject *resultobj = 0;
23798 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23799 int arg2 = (int) 0 ;
23800 wxMenu *arg3 = (wxMenu *) NULL ;
23801 wxMenuEvent *result = 0 ;
23802 int val1 ;
23803 int ecode1 = 0 ;
23804 int val2 ;
23805 int ecode2 = 0 ;
23806 void *argp3 = 0 ;
23807 int res3 = 0 ;
23808 PyObject * obj0 = 0 ;
23809 PyObject * obj1 = 0 ;
23810 PyObject * obj2 = 0 ;
23811 char * kwnames[] = {
23812 (char *) "type",(char *) "winid",(char *) "menu", NULL
23813 };
23814
23815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23816 if (obj0) {
23817 ecode1 = SWIG_AsVal_int(obj0, &val1);
23818 if (!SWIG_IsOK(ecode1)) {
23819 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23820 }
23821 arg1 = static_cast< wxEventType >(val1);
23822 }
23823 if (obj1) {
23824 ecode2 = SWIG_AsVal_int(obj1, &val2);
23825 if (!SWIG_IsOK(ecode2)) {
23826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23827 }
23828 arg2 = static_cast< int >(val2);
23829 }
23830 if (obj2) {
23831 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23832 if (!SWIG_IsOK(res3)) {
23833 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23834 }
23835 arg3 = reinterpret_cast< wxMenu * >(argp3);
23836 }
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23840 wxPyEndAllowThreads(__tstate);
23841 if (PyErr_Occurred()) SWIG_fail;
23842 }
23843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23844 return resultobj;
23845 fail:
23846 return NULL;
23847 }
23848
23849
23850 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23851 PyObject *resultobj = 0;
23852 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23853 int result;
23854 void *argp1 = 0 ;
23855 int res1 = 0 ;
23856 PyObject *swig_obj[1] ;
23857
23858 if (!args) SWIG_fail;
23859 swig_obj[0] = args;
23860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23861 if (!SWIG_IsOK(res1)) {
23862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23863 }
23864 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23865 {
23866 PyThreadState* __tstate = wxPyBeginAllowThreads();
23867 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23868 wxPyEndAllowThreads(__tstate);
23869 if (PyErr_Occurred()) SWIG_fail;
23870 }
23871 resultobj = SWIG_From_int(static_cast< int >(result));
23872 return resultobj;
23873 fail:
23874 return NULL;
23875 }
23876
23877
23878 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23879 PyObject *resultobj = 0;
23880 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23881 bool result;
23882 void *argp1 = 0 ;
23883 int res1 = 0 ;
23884 PyObject *swig_obj[1] ;
23885
23886 if (!args) SWIG_fail;
23887 swig_obj[0] = args;
23888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23889 if (!SWIG_IsOK(res1)) {
23890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23891 }
23892 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23893 {
23894 PyThreadState* __tstate = wxPyBeginAllowThreads();
23895 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23896 wxPyEndAllowThreads(__tstate);
23897 if (PyErr_Occurred()) SWIG_fail;
23898 }
23899 {
23900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23901 }
23902 return resultobj;
23903 fail:
23904 return NULL;
23905 }
23906
23907
23908 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23909 PyObject *resultobj = 0;
23910 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23911 wxMenu *result = 0 ;
23912 void *argp1 = 0 ;
23913 int res1 = 0 ;
23914 PyObject *swig_obj[1] ;
23915
23916 if (!args) SWIG_fail;
23917 swig_obj[0] = args;
23918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23919 if (!SWIG_IsOK(res1)) {
23920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23921 }
23922 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23923 {
23924 PyThreadState* __tstate = wxPyBeginAllowThreads();
23925 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23926 wxPyEndAllowThreads(__tstate);
23927 if (PyErr_Occurred()) SWIG_fail;
23928 }
23929 {
23930 resultobj = wxPyMake_wxObject(result, (bool)0);
23931 }
23932 return resultobj;
23933 fail:
23934 return NULL;
23935 }
23936
23937
23938 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23939 PyObject *obj;
23940 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23941 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
23942 return SWIG_Py_Void();
23943 }
23944
23945 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23946 return SWIG_Python_InitShadowInstance(args);
23947 }
23948
23949 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23950 PyObject *resultobj = 0;
23951 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23952 int arg2 = (int) 0 ;
23953 wxCloseEvent *result = 0 ;
23954 int val1 ;
23955 int ecode1 = 0 ;
23956 int val2 ;
23957 int ecode2 = 0 ;
23958 PyObject * obj0 = 0 ;
23959 PyObject * obj1 = 0 ;
23960 char * kwnames[] = {
23961 (char *) "type",(char *) "winid", NULL
23962 };
23963
23964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23965 if (obj0) {
23966 ecode1 = SWIG_AsVal_int(obj0, &val1);
23967 if (!SWIG_IsOK(ecode1)) {
23968 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23969 }
23970 arg1 = static_cast< wxEventType >(val1);
23971 }
23972 if (obj1) {
23973 ecode2 = SWIG_AsVal_int(obj1, &val2);
23974 if (!SWIG_IsOK(ecode2)) {
23975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
23976 }
23977 arg2 = static_cast< int >(val2);
23978 }
23979 {
23980 PyThreadState* __tstate = wxPyBeginAllowThreads();
23981 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
23982 wxPyEndAllowThreads(__tstate);
23983 if (PyErr_Occurred()) SWIG_fail;
23984 }
23985 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
23986 return resultobj;
23987 fail:
23988 return NULL;
23989 }
23990
23991
23992 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23993 PyObject *resultobj = 0;
23994 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
23995 bool arg2 ;
23996 void *argp1 = 0 ;
23997 int res1 = 0 ;
23998 bool val2 ;
23999 int ecode2 = 0 ;
24000 PyObject * obj0 = 0 ;
24001 PyObject * obj1 = 0 ;
24002 char * kwnames[] = {
24003 (char *) "self",(char *) "logOff", NULL
24004 };
24005
24006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24008 if (!SWIG_IsOK(res1)) {
24009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24010 }
24011 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24012 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24013 if (!SWIG_IsOK(ecode2)) {
24014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24015 }
24016 arg2 = static_cast< bool >(val2);
24017 {
24018 PyThreadState* __tstate = wxPyBeginAllowThreads();
24019 (arg1)->SetLoggingOff(arg2);
24020 wxPyEndAllowThreads(__tstate);
24021 if (PyErr_Occurred()) SWIG_fail;
24022 }
24023 resultobj = SWIG_Py_Void();
24024 return resultobj;
24025 fail:
24026 return NULL;
24027 }
24028
24029
24030 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24031 PyObject *resultobj = 0;
24032 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24033 bool result;
24034 void *argp1 = 0 ;
24035 int res1 = 0 ;
24036 PyObject *swig_obj[1] ;
24037
24038 if (!args) SWIG_fail;
24039 swig_obj[0] = args;
24040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24041 if (!SWIG_IsOK(res1)) {
24042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24043 }
24044 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24045 {
24046 PyThreadState* __tstate = wxPyBeginAllowThreads();
24047 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24048 wxPyEndAllowThreads(__tstate);
24049 if (PyErr_Occurred()) SWIG_fail;
24050 }
24051 {
24052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24053 }
24054 return resultobj;
24055 fail:
24056 return NULL;
24057 }
24058
24059
24060 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24061 PyObject *resultobj = 0;
24062 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24063 bool arg2 = (bool) true ;
24064 void *argp1 = 0 ;
24065 int res1 = 0 ;
24066 bool val2 ;
24067 int ecode2 = 0 ;
24068 PyObject * obj0 = 0 ;
24069 PyObject * obj1 = 0 ;
24070 char * kwnames[] = {
24071 (char *) "self",(char *) "veto", NULL
24072 };
24073
24074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24076 if (!SWIG_IsOK(res1)) {
24077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24078 }
24079 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24080 if (obj1) {
24081 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24082 if (!SWIG_IsOK(ecode2)) {
24083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24084 }
24085 arg2 = static_cast< bool >(val2);
24086 }
24087 {
24088 PyThreadState* __tstate = wxPyBeginAllowThreads();
24089 (arg1)->Veto(arg2);
24090 wxPyEndAllowThreads(__tstate);
24091 if (PyErr_Occurred()) SWIG_fail;
24092 }
24093 resultobj = SWIG_Py_Void();
24094 return resultobj;
24095 fail:
24096 return NULL;
24097 }
24098
24099
24100 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24101 PyObject *resultobj = 0;
24102 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24103 bool result;
24104 void *argp1 = 0 ;
24105 int res1 = 0 ;
24106 PyObject *swig_obj[1] ;
24107
24108 if (!args) SWIG_fail;
24109 swig_obj[0] = args;
24110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24111 if (!SWIG_IsOK(res1)) {
24112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24113 }
24114 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24115 {
24116 PyThreadState* __tstate = wxPyBeginAllowThreads();
24117 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24118 wxPyEndAllowThreads(__tstate);
24119 if (PyErr_Occurred()) SWIG_fail;
24120 }
24121 {
24122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24123 }
24124 return resultobj;
24125 fail:
24126 return NULL;
24127 }
24128
24129
24130 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24131 PyObject *resultobj = 0;
24132 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24133 bool arg2 ;
24134 void *argp1 = 0 ;
24135 int res1 = 0 ;
24136 bool val2 ;
24137 int ecode2 = 0 ;
24138 PyObject * obj0 = 0 ;
24139 PyObject * obj1 = 0 ;
24140 char * kwnames[] = {
24141 (char *) "self",(char *) "canVeto", NULL
24142 };
24143
24144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24146 if (!SWIG_IsOK(res1)) {
24147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24148 }
24149 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24150 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24151 if (!SWIG_IsOK(ecode2)) {
24152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24153 }
24154 arg2 = static_cast< bool >(val2);
24155 {
24156 PyThreadState* __tstate = wxPyBeginAllowThreads();
24157 (arg1)->SetCanVeto(arg2);
24158 wxPyEndAllowThreads(__tstate);
24159 if (PyErr_Occurred()) SWIG_fail;
24160 }
24161 resultobj = SWIG_Py_Void();
24162 return resultobj;
24163 fail:
24164 return NULL;
24165 }
24166
24167
24168 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24169 PyObject *resultobj = 0;
24170 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24171 bool result;
24172 void *argp1 = 0 ;
24173 int res1 = 0 ;
24174 PyObject *swig_obj[1] ;
24175
24176 if (!args) SWIG_fail;
24177 swig_obj[0] = args;
24178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24179 if (!SWIG_IsOK(res1)) {
24180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24181 }
24182 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24183 {
24184 PyThreadState* __tstate = wxPyBeginAllowThreads();
24185 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24186 wxPyEndAllowThreads(__tstate);
24187 if (PyErr_Occurred()) SWIG_fail;
24188 }
24189 {
24190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24191 }
24192 return resultobj;
24193 fail:
24194 return NULL;
24195 }
24196
24197
24198 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24199 PyObject *obj;
24200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24201 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24202 return SWIG_Py_Void();
24203 }
24204
24205 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24206 return SWIG_Python_InitShadowInstance(args);
24207 }
24208
24209 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24210 PyObject *resultobj = 0;
24211 int arg1 = (int) 0 ;
24212 bool arg2 = (bool) false ;
24213 wxShowEvent *result = 0 ;
24214 int val1 ;
24215 int ecode1 = 0 ;
24216 bool val2 ;
24217 int ecode2 = 0 ;
24218 PyObject * obj0 = 0 ;
24219 PyObject * obj1 = 0 ;
24220 char * kwnames[] = {
24221 (char *) "winid",(char *) "show", NULL
24222 };
24223
24224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24225 if (obj0) {
24226 ecode1 = SWIG_AsVal_int(obj0, &val1);
24227 if (!SWIG_IsOK(ecode1)) {
24228 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24229 }
24230 arg1 = static_cast< int >(val1);
24231 }
24232 if (obj1) {
24233 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24234 if (!SWIG_IsOK(ecode2)) {
24235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24236 }
24237 arg2 = static_cast< bool >(val2);
24238 }
24239 {
24240 PyThreadState* __tstate = wxPyBeginAllowThreads();
24241 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24242 wxPyEndAllowThreads(__tstate);
24243 if (PyErr_Occurred()) SWIG_fail;
24244 }
24245 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24246 return resultobj;
24247 fail:
24248 return NULL;
24249 }
24250
24251
24252 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24253 PyObject *resultobj = 0;
24254 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24255 bool arg2 ;
24256 void *argp1 = 0 ;
24257 int res1 = 0 ;
24258 bool val2 ;
24259 int ecode2 = 0 ;
24260 PyObject * obj0 = 0 ;
24261 PyObject * obj1 = 0 ;
24262 char * kwnames[] = {
24263 (char *) "self",(char *) "show", NULL
24264 };
24265
24266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24268 if (!SWIG_IsOK(res1)) {
24269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24270 }
24271 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24272 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24273 if (!SWIG_IsOK(ecode2)) {
24274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24275 }
24276 arg2 = static_cast< bool >(val2);
24277 {
24278 PyThreadState* __tstate = wxPyBeginAllowThreads();
24279 (arg1)->SetShow(arg2);
24280 wxPyEndAllowThreads(__tstate);
24281 if (PyErr_Occurred()) SWIG_fail;
24282 }
24283 resultobj = SWIG_Py_Void();
24284 return resultobj;
24285 fail:
24286 return NULL;
24287 }
24288
24289
24290 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24291 PyObject *resultobj = 0;
24292 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24293 bool result;
24294 void *argp1 = 0 ;
24295 int res1 = 0 ;
24296 PyObject *swig_obj[1] ;
24297
24298 if (!args) SWIG_fail;
24299 swig_obj[0] = args;
24300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24301 if (!SWIG_IsOK(res1)) {
24302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24303 }
24304 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24305 {
24306 PyThreadState* __tstate = wxPyBeginAllowThreads();
24307 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24308 wxPyEndAllowThreads(__tstate);
24309 if (PyErr_Occurred()) SWIG_fail;
24310 }
24311 {
24312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24313 }
24314 return resultobj;
24315 fail:
24316 return NULL;
24317 }
24318
24319
24320 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24321 PyObject *obj;
24322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24323 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24324 return SWIG_Py_Void();
24325 }
24326
24327 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24328 return SWIG_Python_InitShadowInstance(args);
24329 }
24330
24331 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24332 PyObject *resultobj = 0;
24333 int arg1 = (int) 0 ;
24334 bool arg2 = (bool) true ;
24335 wxIconizeEvent *result = 0 ;
24336 int val1 ;
24337 int ecode1 = 0 ;
24338 bool val2 ;
24339 int ecode2 = 0 ;
24340 PyObject * obj0 = 0 ;
24341 PyObject * obj1 = 0 ;
24342 char * kwnames[] = {
24343 (char *) "id",(char *) "iconized", NULL
24344 };
24345
24346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24347 if (obj0) {
24348 ecode1 = SWIG_AsVal_int(obj0, &val1);
24349 if (!SWIG_IsOK(ecode1)) {
24350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24351 }
24352 arg1 = static_cast< int >(val1);
24353 }
24354 if (obj1) {
24355 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24356 if (!SWIG_IsOK(ecode2)) {
24357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24358 }
24359 arg2 = static_cast< bool >(val2);
24360 }
24361 {
24362 PyThreadState* __tstate = wxPyBeginAllowThreads();
24363 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24364 wxPyEndAllowThreads(__tstate);
24365 if (PyErr_Occurred()) SWIG_fail;
24366 }
24367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24368 return resultobj;
24369 fail:
24370 return NULL;
24371 }
24372
24373
24374 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24375 PyObject *resultobj = 0;
24376 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24377 bool result;
24378 void *argp1 = 0 ;
24379 int res1 = 0 ;
24380 PyObject *swig_obj[1] ;
24381
24382 if (!args) SWIG_fail;
24383 swig_obj[0] = args;
24384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24385 if (!SWIG_IsOK(res1)) {
24386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24387 }
24388 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24389 {
24390 PyThreadState* __tstate = wxPyBeginAllowThreads();
24391 result = (bool)(arg1)->Iconized();
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 {
24396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24397 }
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24405 PyObject *obj;
24406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24407 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24408 return SWIG_Py_Void();
24409 }
24410
24411 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24412 return SWIG_Python_InitShadowInstance(args);
24413 }
24414
24415 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24416 PyObject *resultobj = 0;
24417 int arg1 = (int) 0 ;
24418 wxMaximizeEvent *result = 0 ;
24419 int val1 ;
24420 int ecode1 = 0 ;
24421 PyObject * obj0 = 0 ;
24422 char * kwnames[] = {
24423 (char *) "id", NULL
24424 };
24425
24426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24427 if (obj0) {
24428 ecode1 = SWIG_AsVal_int(obj0, &val1);
24429 if (!SWIG_IsOK(ecode1)) {
24430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24431 }
24432 arg1 = static_cast< int >(val1);
24433 }
24434 {
24435 PyThreadState* __tstate = wxPyBeginAllowThreads();
24436 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24437 wxPyEndAllowThreads(__tstate);
24438 if (PyErr_Occurred()) SWIG_fail;
24439 }
24440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24441 return resultobj;
24442 fail:
24443 return NULL;
24444 }
24445
24446
24447 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24448 PyObject *obj;
24449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24450 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24451 return SWIG_Py_Void();
24452 }
24453
24454 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24455 return SWIG_Python_InitShadowInstance(args);
24456 }
24457
24458 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24459 PyObject *resultobj = 0;
24460 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24461 wxPoint result;
24462 void *argp1 = 0 ;
24463 int res1 = 0 ;
24464 PyObject *swig_obj[1] ;
24465
24466 if (!args) SWIG_fail;
24467 swig_obj[0] = args;
24468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24469 if (!SWIG_IsOK(res1)) {
24470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24471 }
24472 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24473 {
24474 PyThreadState* __tstate = wxPyBeginAllowThreads();
24475 result = (arg1)->GetPosition();
24476 wxPyEndAllowThreads(__tstate);
24477 if (PyErr_Occurred()) SWIG_fail;
24478 }
24479 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24480 return resultobj;
24481 fail:
24482 return NULL;
24483 }
24484
24485
24486 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24487 PyObject *resultobj = 0;
24488 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24489 int result;
24490 void *argp1 = 0 ;
24491 int res1 = 0 ;
24492 PyObject *swig_obj[1] ;
24493
24494 if (!args) SWIG_fail;
24495 swig_obj[0] = args;
24496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24497 if (!SWIG_IsOK(res1)) {
24498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24499 }
24500 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24501 {
24502 PyThreadState* __tstate = wxPyBeginAllowThreads();
24503 result = (int)(arg1)->GetNumberOfFiles();
24504 wxPyEndAllowThreads(__tstate);
24505 if (PyErr_Occurred()) SWIG_fail;
24506 }
24507 resultobj = SWIG_From_int(static_cast< int >(result));
24508 return resultobj;
24509 fail:
24510 return NULL;
24511 }
24512
24513
24514 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24515 PyObject *resultobj = 0;
24516 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24517 PyObject *result = 0 ;
24518 void *argp1 = 0 ;
24519 int res1 = 0 ;
24520 PyObject *swig_obj[1] ;
24521
24522 if (!args) SWIG_fail;
24523 swig_obj[0] = args;
24524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24525 if (!SWIG_IsOK(res1)) {
24526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24527 }
24528 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24529 {
24530 PyThreadState* __tstate = wxPyBeginAllowThreads();
24531 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24532 wxPyEndAllowThreads(__tstate);
24533 if (PyErr_Occurred()) SWIG_fail;
24534 }
24535 resultobj = result;
24536 return resultobj;
24537 fail:
24538 return NULL;
24539 }
24540
24541
24542 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24543 PyObject *obj;
24544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24545 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24546 return SWIG_Py_Void();
24547 }
24548
24549 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24550 PyObject *resultobj = 0;
24551 int arg1 = (int) 0 ;
24552 wxUpdateUIEvent *result = 0 ;
24553 int val1 ;
24554 int ecode1 = 0 ;
24555 PyObject * obj0 = 0 ;
24556 char * kwnames[] = {
24557 (char *) "commandId", NULL
24558 };
24559
24560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24561 if (obj0) {
24562 ecode1 = SWIG_AsVal_int(obj0, &val1);
24563 if (!SWIG_IsOK(ecode1)) {
24564 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24565 }
24566 arg1 = static_cast< int >(val1);
24567 }
24568 {
24569 PyThreadState* __tstate = wxPyBeginAllowThreads();
24570 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24571 wxPyEndAllowThreads(__tstate);
24572 if (PyErr_Occurred()) SWIG_fail;
24573 }
24574 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24575 return resultobj;
24576 fail:
24577 return NULL;
24578 }
24579
24580
24581 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24582 PyObject *resultobj = 0;
24583 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24584 bool result;
24585 void *argp1 = 0 ;
24586 int res1 = 0 ;
24587 PyObject *swig_obj[1] ;
24588
24589 if (!args) SWIG_fail;
24590 swig_obj[0] = args;
24591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24592 if (!SWIG_IsOK(res1)) {
24593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24594 }
24595 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24596 {
24597 PyThreadState* __tstate = wxPyBeginAllowThreads();
24598 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24599 wxPyEndAllowThreads(__tstate);
24600 if (PyErr_Occurred()) SWIG_fail;
24601 }
24602 {
24603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24604 }
24605 return resultobj;
24606 fail:
24607 return NULL;
24608 }
24609
24610
24611 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24612 PyObject *resultobj = 0;
24613 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24614 bool result;
24615 void *argp1 = 0 ;
24616 int res1 = 0 ;
24617 PyObject *swig_obj[1] ;
24618
24619 if (!args) SWIG_fail;
24620 swig_obj[0] = args;
24621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24622 if (!SWIG_IsOK(res1)) {
24623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24624 }
24625 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24626 {
24627 PyThreadState* __tstate = wxPyBeginAllowThreads();
24628 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24629 wxPyEndAllowThreads(__tstate);
24630 if (PyErr_Occurred()) SWIG_fail;
24631 }
24632 {
24633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24634 }
24635 return resultobj;
24636 fail:
24637 return NULL;
24638 }
24639
24640
24641 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24642 PyObject *resultobj = 0;
24643 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24644 bool result;
24645 void *argp1 = 0 ;
24646 int res1 = 0 ;
24647 PyObject *swig_obj[1] ;
24648
24649 if (!args) SWIG_fail;
24650 swig_obj[0] = args;
24651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24652 if (!SWIG_IsOK(res1)) {
24653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24654 }
24655 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24656 {
24657 PyThreadState* __tstate = wxPyBeginAllowThreads();
24658 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24659 wxPyEndAllowThreads(__tstate);
24660 if (PyErr_Occurred()) SWIG_fail;
24661 }
24662 {
24663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24664 }
24665 return resultobj;
24666 fail:
24667 return NULL;
24668 }
24669
24670
24671 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24672 PyObject *resultobj = 0;
24673 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24674 wxString result;
24675 void *argp1 = 0 ;
24676 int res1 = 0 ;
24677 PyObject *swig_obj[1] ;
24678
24679 if (!args) SWIG_fail;
24680 swig_obj[0] = args;
24681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24682 if (!SWIG_IsOK(res1)) {
24683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24684 }
24685 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24686 {
24687 PyThreadState* __tstate = wxPyBeginAllowThreads();
24688 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24689 wxPyEndAllowThreads(__tstate);
24690 if (PyErr_Occurred()) SWIG_fail;
24691 }
24692 {
24693 #if wxUSE_UNICODE
24694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24695 #else
24696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24697 #endif
24698 }
24699 return resultobj;
24700 fail:
24701 return NULL;
24702 }
24703
24704
24705 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24706 PyObject *resultobj = 0;
24707 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24708 bool result;
24709 void *argp1 = 0 ;
24710 int res1 = 0 ;
24711 PyObject *swig_obj[1] ;
24712
24713 if (!args) SWIG_fail;
24714 swig_obj[0] = args;
24715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24716 if (!SWIG_IsOK(res1)) {
24717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24718 }
24719 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24720 {
24721 PyThreadState* __tstate = wxPyBeginAllowThreads();
24722 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24723 wxPyEndAllowThreads(__tstate);
24724 if (PyErr_Occurred()) SWIG_fail;
24725 }
24726 {
24727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24728 }
24729 return resultobj;
24730 fail:
24731 return NULL;
24732 }
24733
24734
24735 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24736 PyObject *resultobj = 0;
24737 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24738 bool result;
24739 void *argp1 = 0 ;
24740 int res1 = 0 ;
24741 PyObject *swig_obj[1] ;
24742
24743 if (!args) SWIG_fail;
24744 swig_obj[0] = args;
24745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24746 if (!SWIG_IsOK(res1)) {
24747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24748 }
24749 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24750 {
24751 PyThreadState* __tstate = wxPyBeginAllowThreads();
24752 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24753 wxPyEndAllowThreads(__tstate);
24754 if (PyErr_Occurred()) SWIG_fail;
24755 }
24756 {
24757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24758 }
24759 return resultobj;
24760 fail:
24761 return NULL;
24762 }
24763
24764
24765 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24766 PyObject *resultobj = 0;
24767 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24768 bool result;
24769 void *argp1 = 0 ;
24770 int res1 = 0 ;
24771 PyObject *swig_obj[1] ;
24772
24773 if (!args) SWIG_fail;
24774 swig_obj[0] = args;
24775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24776 if (!SWIG_IsOK(res1)) {
24777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24778 }
24779 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24780 {
24781 PyThreadState* __tstate = wxPyBeginAllowThreads();
24782 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24783 wxPyEndAllowThreads(__tstate);
24784 if (PyErr_Occurred()) SWIG_fail;
24785 }
24786 {
24787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24788 }
24789 return resultobj;
24790 fail:
24791 return NULL;
24792 }
24793
24794
24795 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24796 PyObject *resultobj = 0;
24797 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24798 bool result;
24799 void *argp1 = 0 ;
24800 int res1 = 0 ;
24801 PyObject *swig_obj[1] ;
24802
24803 if (!args) SWIG_fail;
24804 swig_obj[0] = args;
24805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24806 if (!SWIG_IsOK(res1)) {
24807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24808 }
24809 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24810 {
24811 PyThreadState* __tstate = wxPyBeginAllowThreads();
24812 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24813 wxPyEndAllowThreads(__tstate);
24814 if (PyErr_Occurred()) SWIG_fail;
24815 }
24816 {
24817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24818 }
24819 return resultobj;
24820 fail:
24821 return NULL;
24822 }
24823
24824
24825 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24826 PyObject *resultobj = 0;
24827 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24828 bool arg2 ;
24829 void *argp1 = 0 ;
24830 int res1 = 0 ;
24831 bool val2 ;
24832 int ecode2 = 0 ;
24833 PyObject * obj0 = 0 ;
24834 PyObject * obj1 = 0 ;
24835 char * kwnames[] = {
24836 (char *) "self",(char *) "check", NULL
24837 };
24838
24839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24841 if (!SWIG_IsOK(res1)) {
24842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24843 }
24844 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24845 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24846 if (!SWIG_IsOK(ecode2)) {
24847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24848 }
24849 arg2 = static_cast< bool >(val2);
24850 {
24851 PyThreadState* __tstate = wxPyBeginAllowThreads();
24852 (arg1)->Check(arg2);
24853 wxPyEndAllowThreads(__tstate);
24854 if (PyErr_Occurred()) SWIG_fail;
24855 }
24856 resultobj = SWIG_Py_Void();
24857 return resultobj;
24858 fail:
24859 return NULL;
24860 }
24861
24862
24863 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24864 PyObject *resultobj = 0;
24865 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24866 bool arg2 ;
24867 void *argp1 = 0 ;
24868 int res1 = 0 ;
24869 bool val2 ;
24870 int ecode2 = 0 ;
24871 PyObject * obj0 = 0 ;
24872 PyObject * obj1 = 0 ;
24873 char * kwnames[] = {
24874 (char *) "self",(char *) "enable", NULL
24875 };
24876
24877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24879 if (!SWIG_IsOK(res1)) {
24880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24881 }
24882 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24883 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24884 if (!SWIG_IsOK(ecode2)) {
24885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24886 }
24887 arg2 = static_cast< bool >(val2);
24888 {
24889 PyThreadState* __tstate = wxPyBeginAllowThreads();
24890 (arg1)->Enable(arg2);
24891 wxPyEndAllowThreads(__tstate);
24892 if (PyErr_Occurred()) SWIG_fail;
24893 }
24894 resultobj = SWIG_Py_Void();
24895 return resultobj;
24896 fail:
24897 return NULL;
24898 }
24899
24900
24901 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24902 PyObject *resultobj = 0;
24903 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24904 bool arg2 ;
24905 void *argp1 = 0 ;
24906 int res1 = 0 ;
24907 bool val2 ;
24908 int ecode2 = 0 ;
24909 PyObject * obj0 = 0 ;
24910 PyObject * obj1 = 0 ;
24911 char * kwnames[] = {
24912 (char *) "self",(char *) "show", NULL
24913 };
24914
24915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24917 if (!SWIG_IsOK(res1)) {
24918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24919 }
24920 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24921 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24922 if (!SWIG_IsOK(ecode2)) {
24923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24924 }
24925 arg2 = static_cast< bool >(val2);
24926 {
24927 PyThreadState* __tstate = wxPyBeginAllowThreads();
24928 (arg1)->Show(arg2);
24929 wxPyEndAllowThreads(__tstate);
24930 if (PyErr_Occurred()) SWIG_fail;
24931 }
24932 resultobj = SWIG_Py_Void();
24933 return resultobj;
24934 fail:
24935 return NULL;
24936 }
24937
24938
24939 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24940 PyObject *resultobj = 0;
24941 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24942 wxString *arg2 = 0 ;
24943 void *argp1 = 0 ;
24944 int res1 = 0 ;
24945 bool temp2 = false ;
24946 PyObject * obj0 = 0 ;
24947 PyObject * obj1 = 0 ;
24948 char * kwnames[] = {
24949 (char *) "self",(char *) "text", NULL
24950 };
24951
24952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
24953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24954 if (!SWIG_IsOK(res1)) {
24955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24956 }
24957 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24958 {
24959 arg2 = wxString_in_helper(obj1);
24960 if (arg2 == NULL) SWIG_fail;
24961 temp2 = true;
24962 }
24963 {
24964 PyThreadState* __tstate = wxPyBeginAllowThreads();
24965 (arg1)->SetText((wxString const &)*arg2);
24966 wxPyEndAllowThreads(__tstate);
24967 if (PyErr_Occurred()) SWIG_fail;
24968 }
24969 resultobj = SWIG_Py_Void();
24970 {
24971 if (temp2)
24972 delete arg2;
24973 }
24974 return resultobj;
24975 fail:
24976 {
24977 if (temp2)
24978 delete arg2;
24979 }
24980 return NULL;
24981 }
24982
24983
24984 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24985 PyObject *resultobj = 0;
24986 long arg1 ;
24987 long val1 ;
24988 int ecode1 = 0 ;
24989 PyObject * obj0 = 0 ;
24990 char * kwnames[] = {
24991 (char *) "updateInterval", NULL
24992 };
24993
24994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
24995 ecode1 = SWIG_AsVal_long(obj0, &val1);
24996 if (!SWIG_IsOK(ecode1)) {
24997 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
24998 }
24999 arg1 = static_cast< long >(val1);
25000 {
25001 PyThreadState* __tstate = wxPyBeginAllowThreads();
25002 wxUpdateUIEvent::SetUpdateInterval(arg1);
25003 wxPyEndAllowThreads(__tstate);
25004 if (PyErr_Occurred()) SWIG_fail;
25005 }
25006 resultobj = SWIG_Py_Void();
25007 return resultobj;
25008 fail:
25009 return NULL;
25010 }
25011
25012
25013 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25014 PyObject *resultobj = 0;
25015 long result;
25016
25017 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25018 {
25019 PyThreadState* __tstate = wxPyBeginAllowThreads();
25020 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25021 wxPyEndAllowThreads(__tstate);
25022 if (PyErr_Occurred()) SWIG_fail;
25023 }
25024 resultobj = SWIG_From_long(static_cast< long >(result));
25025 return resultobj;
25026 fail:
25027 return NULL;
25028 }
25029
25030
25031 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25032 PyObject *resultobj = 0;
25033 wxWindow *arg1 = (wxWindow *) 0 ;
25034 bool result;
25035 void *argp1 = 0 ;
25036 int res1 = 0 ;
25037 PyObject * obj0 = 0 ;
25038 char * kwnames[] = {
25039 (char *) "win", NULL
25040 };
25041
25042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25044 if (!SWIG_IsOK(res1)) {
25045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25046 }
25047 arg1 = reinterpret_cast< wxWindow * >(argp1);
25048 {
25049 PyThreadState* __tstate = wxPyBeginAllowThreads();
25050 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25051 wxPyEndAllowThreads(__tstate);
25052 if (PyErr_Occurred()) SWIG_fail;
25053 }
25054 {
25055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25056 }
25057 return resultobj;
25058 fail:
25059 return NULL;
25060 }
25061
25062
25063 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25064 PyObject *resultobj = 0;
25065
25066 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25067 {
25068 PyThreadState* __tstate = wxPyBeginAllowThreads();
25069 wxUpdateUIEvent::ResetUpdateTime();
25070 wxPyEndAllowThreads(__tstate);
25071 if (PyErr_Occurred()) SWIG_fail;
25072 }
25073 resultobj = SWIG_Py_Void();
25074 return resultobj;
25075 fail:
25076 return NULL;
25077 }
25078
25079
25080 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25081 PyObject *resultobj = 0;
25082 wxUpdateUIMode arg1 ;
25083 int val1 ;
25084 int ecode1 = 0 ;
25085 PyObject * obj0 = 0 ;
25086 char * kwnames[] = {
25087 (char *) "mode", NULL
25088 };
25089
25090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25091 ecode1 = SWIG_AsVal_int(obj0, &val1);
25092 if (!SWIG_IsOK(ecode1)) {
25093 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25094 }
25095 arg1 = static_cast< wxUpdateUIMode >(val1);
25096 {
25097 PyThreadState* __tstate = wxPyBeginAllowThreads();
25098 wxUpdateUIEvent::SetMode(arg1);
25099 wxPyEndAllowThreads(__tstate);
25100 if (PyErr_Occurred()) SWIG_fail;
25101 }
25102 resultobj = SWIG_Py_Void();
25103 return resultobj;
25104 fail:
25105 return NULL;
25106 }
25107
25108
25109 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25110 PyObject *resultobj = 0;
25111 wxUpdateUIMode result;
25112
25113 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25114 {
25115 PyThreadState* __tstate = wxPyBeginAllowThreads();
25116 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25117 wxPyEndAllowThreads(__tstate);
25118 if (PyErr_Occurred()) SWIG_fail;
25119 }
25120 resultobj = SWIG_From_int(static_cast< int >(result));
25121 return resultobj;
25122 fail:
25123 return NULL;
25124 }
25125
25126
25127 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25128 PyObject *obj;
25129 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25130 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25131 return SWIG_Py_Void();
25132 }
25133
25134 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25135 return SWIG_Python_InitShadowInstance(args);
25136 }
25137
25138 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25139 PyObject *resultobj = 0;
25140 wxSysColourChangedEvent *result = 0 ;
25141
25142 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25143 {
25144 PyThreadState* __tstate = wxPyBeginAllowThreads();
25145 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25146 wxPyEndAllowThreads(__tstate);
25147 if (PyErr_Occurred()) SWIG_fail;
25148 }
25149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25150 return resultobj;
25151 fail:
25152 return NULL;
25153 }
25154
25155
25156 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25157 PyObject *obj;
25158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25159 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25160 return SWIG_Py_Void();
25161 }
25162
25163 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25164 return SWIG_Python_InitShadowInstance(args);
25165 }
25166
25167 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25168 PyObject *resultobj = 0;
25169 int arg1 = (int) 0 ;
25170 wxWindow *arg2 = (wxWindow *) NULL ;
25171 wxMouseCaptureChangedEvent *result = 0 ;
25172 int val1 ;
25173 int ecode1 = 0 ;
25174 void *argp2 = 0 ;
25175 int res2 = 0 ;
25176 PyObject * obj0 = 0 ;
25177 PyObject * obj1 = 0 ;
25178 char * kwnames[] = {
25179 (char *) "winid",(char *) "gainedCapture", NULL
25180 };
25181
25182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25183 if (obj0) {
25184 ecode1 = SWIG_AsVal_int(obj0, &val1);
25185 if (!SWIG_IsOK(ecode1)) {
25186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25187 }
25188 arg1 = static_cast< int >(val1);
25189 }
25190 if (obj1) {
25191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25192 if (!SWIG_IsOK(res2)) {
25193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25194 }
25195 arg2 = reinterpret_cast< wxWindow * >(argp2);
25196 }
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25204 return resultobj;
25205 fail:
25206 return NULL;
25207 }
25208
25209
25210 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25211 PyObject *resultobj = 0;
25212 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25213 wxWindow *result = 0 ;
25214 void *argp1 = 0 ;
25215 int res1 = 0 ;
25216 PyObject *swig_obj[1] ;
25217
25218 if (!args) SWIG_fail;
25219 swig_obj[0] = args;
25220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25221 if (!SWIG_IsOK(res1)) {
25222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25223 }
25224 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25225 {
25226 PyThreadState* __tstate = wxPyBeginAllowThreads();
25227 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25228 wxPyEndAllowThreads(__tstate);
25229 if (PyErr_Occurred()) SWIG_fail;
25230 }
25231 {
25232 resultobj = wxPyMake_wxObject(result, (bool)0);
25233 }
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25241 PyObject *obj;
25242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25243 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25244 return SWIG_Py_Void();
25245 }
25246
25247 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 return SWIG_Python_InitShadowInstance(args);
25249 }
25250
25251 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25252 PyObject *resultobj = 0;
25253 wxDisplayChangedEvent *result = 0 ;
25254
25255 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25256 {
25257 PyThreadState* __tstate = wxPyBeginAllowThreads();
25258 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25259 wxPyEndAllowThreads(__tstate);
25260 if (PyErr_Occurred()) SWIG_fail;
25261 }
25262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25263 return resultobj;
25264 fail:
25265 return NULL;
25266 }
25267
25268
25269 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25270 PyObject *obj;
25271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25272 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25273 return SWIG_Py_Void();
25274 }
25275
25276 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25277 return SWIG_Python_InitShadowInstance(args);
25278 }
25279
25280 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25281 PyObject *resultobj = 0;
25282 int arg1 = (int) 0 ;
25283 wxPaletteChangedEvent *result = 0 ;
25284 int val1 ;
25285 int ecode1 = 0 ;
25286 PyObject * obj0 = 0 ;
25287 char * kwnames[] = {
25288 (char *) "id", NULL
25289 };
25290
25291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25292 if (obj0) {
25293 ecode1 = SWIG_AsVal_int(obj0, &val1);
25294 if (!SWIG_IsOK(ecode1)) {
25295 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25296 }
25297 arg1 = static_cast< int >(val1);
25298 }
25299 {
25300 PyThreadState* __tstate = wxPyBeginAllowThreads();
25301 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25302 wxPyEndAllowThreads(__tstate);
25303 if (PyErr_Occurred()) SWIG_fail;
25304 }
25305 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25306 return resultobj;
25307 fail:
25308 return NULL;
25309 }
25310
25311
25312 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25313 PyObject *resultobj = 0;
25314 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25315 wxWindow *arg2 = (wxWindow *) 0 ;
25316 void *argp1 = 0 ;
25317 int res1 = 0 ;
25318 void *argp2 = 0 ;
25319 int res2 = 0 ;
25320 PyObject * obj0 = 0 ;
25321 PyObject * obj1 = 0 ;
25322 char * kwnames[] = {
25323 (char *) "self",(char *) "win", NULL
25324 };
25325
25326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25328 if (!SWIG_IsOK(res1)) {
25329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25330 }
25331 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25332 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25333 if (!SWIG_IsOK(res2)) {
25334 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25335 }
25336 arg2 = reinterpret_cast< wxWindow * >(argp2);
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 (arg1)->SetChangedWindow(arg2);
25340 wxPyEndAllowThreads(__tstate);
25341 if (PyErr_Occurred()) SWIG_fail;
25342 }
25343 resultobj = SWIG_Py_Void();
25344 return resultobj;
25345 fail:
25346 return NULL;
25347 }
25348
25349
25350 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25351 PyObject *resultobj = 0;
25352 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25353 wxWindow *result = 0 ;
25354 void *argp1 = 0 ;
25355 int res1 = 0 ;
25356 PyObject *swig_obj[1] ;
25357
25358 if (!args) SWIG_fail;
25359 swig_obj[0] = args;
25360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25361 if (!SWIG_IsOK(res1)) {
25362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25363 }
25364 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25365 {
25366 PyThreadState* __tstate = wxPyBeginAllowThreads();
25367 result = (wxWindow *)(arg1)->GetChangedWindow();
25368 wxPyEndAllowThreads(__tstate);
25369 if (PyErr_Occurred()) SWIG_fail;
25370 }
25371 {
25372 resultobj = wxPyMake_wxObject(result, (bool)0);
25373 }
25374 return resultobj;
25375 fail:
25376 return NULL;
25377 }
25378
25379
25380 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25381 PyObject *obj;
25382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25383 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25384 return SWIG_Py_Void();
25385 }
25386
25387 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25388 return SWIG_Python_InitShadowInstance(args);
25389 }
25390
25391 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25392 PyObject *resultobj = 0;
25393 int arg1 = (int) 0 ;
25394 wxQueryNewPaletteEvent *result = 0 ;
25395 int val1 ;
25396 int ecode1 = 0 ;
25397 PyObject * obj0 = 0 ;
25398 char * kwnames[] = {
25399 (char *) "winid", NULL
25400 };
25401
25402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25403 if (obj0) {
25404 ecode1 = SWIG_AsVal_int(obj0, &val1);
25405 if (!SWIG_IsOK(ecode1)) {
25406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25407 }
25408 arg1 = static_cast< int >(val1);
25409 }
25410 {
25411 PyThreadState* __tstate = wxPyBeginAllowThreads();
25412 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25413 wxPyEndAllowThreads(__tstate);
25414 if (PyErr_Occurred()) SWIG_fail;
25415 }
25416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25417 return resultobj;
25418 fail:
25419 return NULL;
25420 }
25421
25422
25423 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25424 PyObject *resultobj = 0;
25425 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25426 bool arg2 ;
25427 void *argp1 = 0 ;
25428 int res1 = 0 ;
25429 bool val2 ;
25430 int ecode2 = 0 ;
25431 PyObject * obj0 = 0 ;
25432 PyObject * obj1 = 0 ;
25433 char * kwnames[] = {
25434 (char *) "self",(char *) "realized", NULL
25435 };
25436
25437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25439 if (!SWIG_IsOK(res1)) {
25440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25441 }
25442 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25443 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25444 if (!SWIG_IsOK(ecode2)) {
25445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25446 }
25447 arg2 = static_cast< bool >(val2);
25448 {
25449 PyThreadState* __tstate = wxPyBeginAllowThreads();
25450 (arg1)->SetPaletteRealized(arg2);
25451 wxPyEndAllowThreads(__tstate);
25452 if (PyErr_Occurred()) SWIG_fail;
25453 }
25454 resultobj = SWIG_Py_Void();
25455 return resultobj;
25456 fail:
25457 return NULL;
25458 }
25459
25460
25461 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25462 PyObject *resultobj = 0;
25463 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25464 bool result;
25465 void *argp1 = 0 ;
25466 int res1 = 0 ;
25467 PyObject *swig_obj[1] ;
25468
25469 if (!args) SWIG_fail;
25470 swig_obj[0] = args;
25471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25472 if (!SWIG_IsOK(res1)) {
25473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25474 }
25475 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25476 {
25477 PyThreadState* __tstate = wxPyBeginAllowThreads();
25478 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25479 wxPyEndAllowThreads(__tstate);
25480 if (PyErr_Occurred()) SWIG_fail;
25481 }
25482 {
25483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25484 }
25485 return resultobj;
25486 fail:
25487 return NULL;
25488 }
25489
25490
25491 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25492 PyObject *obj;
25493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25494 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25495 return SWIG_Py_Void();
25496 }
25497
25498 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25499 return SWIG_Python_InitShadowInstance(args);
25500 }
25501
25502 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25503 PyObject *resultobj = 0;
25504 wxNavigationKeyEvent *result = 0 ;
25505
25506 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25507 {
25508 PyThreadState* __tstate = wxPyBeginAllowThreads();
25509 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25510 wxPyEndAllowThreads(__tstate);
25511 if (PyErr_Occurred()) SWIG_fail;
25512 }
25513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25514 return resultobj;
25515 fail:
25516 return NULL;
25517 }
25518
25519
25520 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25521 PyObject *resultobj = 0;
25522 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25523 bool result;
25524 void *argp1 = 0 ;
25525 int res1 = 0 ;
25526 PyObject *swig_obj[1] ;
25527
25528 if (!args) SWIG_fail;
25529 swig_obj[0] = args;
25530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25531 if (!SWIG_IsOK(res1)) {
25532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25533 }
25534 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25535 {
25536 PyThreadState* __tstate = wxPyBeginAllowThreads();
25537 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25538 wxPyEndAllowThreads(__tstate);
25539 if (PyErr_Occurred()) SWIG_fail;
25540 }
25541 {
25542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25543 }
25544 return resultobj;
25545 fail:
25546 return NULL;
25547 }
25548
25549
25550 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25551 PyObject *resultobj = 0;
25552 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25553 bool arg2 ;
25554 void *argp1 = 0 ;
25555 int res1 = 0 ;
25556 bool val2 ;
25557 int ecode2 = 0 ;
25558 PyObject * obj0 = 0 ;
25559 PyObject * obj1 = 0 ;
25560 char * kwnames[] = {
25561 (char *) "self",(char *) "forward", NULL
25562 };
25563
25564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25566 if (!SWIG_IsOK(res1)) {
25567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25568 }
25569 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25570 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25571 if (!SWIG_IsOK(ecode2)) {
25572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25573 }
25574 arg2 = static_cast< bool >(val2);
25575 {
25576 PyThreadState* __tstate = wxPyBeginAllowThreads();
25577 (arg1)->SetDirection(arg2);
25578 wxPyEndAllowThreads(__tstate);
25579 if (PyErr_Occurred()) SWIG_fail;
25580 }
25581 resultobj = SWIG_Py_Void();
25582 return resultobj;
25583 fail:
25584 return NULL;
25585 }
25586
25587
25588 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25589 PyObject *resultobj = 0;
25590 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25591 bool result;
25592 void *argp1 = 0 ;
25593 int res1 = 0 ;
25594 PyObject *swig_obj[1] ;
25595
25596 if (!args) SWIG_fail;
25597 swig_obj[0] = args;
25598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25599 if (!SWIG_IsOK(res1)) {
25600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25601 }
25602 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25603 {
25604 PyThreadState* __tstate = wxPyBeginAllowThreads();
25605 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25606 wxPyEndAllowThreads(__tstate);
25607 if (PyErr_Occurred()) SWIG_fail;
25608 }
25609 {
25610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25611 }
25612 return resultobj;
25613 fail:
25614 return NULL;
25615 }
25616
25617
25618 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25619 PyObject *resultobj = 0;
25620 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25621 bool arg2 ;
25622 void *argp1 = 0 ;
25623 int res1 = 0 ;
25624 bool val2 ;
25625 int ecode2 = 0 ;
25626 PyObject * obj0 = 0 ;
25627 PyObject * obj1 = 0 ;
25628 char * kwnames[] = {
25629 (char *) "self",(char *) "ischange", NULL
25630 };
25631
25632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25634 if (!SWIG_IsOK(res1)) {
25635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25636 }
25637 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25638 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25639 if (!SWIG_IsOK(ecode2)) {
25640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25641 }
25642 arg2 = static_cast< bool >(val2);
25643 {
25644 PyThreadState* __tstate = wxPyBeginAllowThreads();
25645 (arg1)->SetWindowChange(arg2);
25646 wxPyEndAllowThreads(__tstate);
25647 if (PyErr_Occurred()) SWIG_fail;
25648 }
25649 resultobj = SWIG_Py_Void();
25650 return resultobj;
25651 fail:
25652 return NULL;
25653 }
25654
25655
25656 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25657 PyObject *resultobj = 0;
25658 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25659 bool result;
25660 void *argp1 = 0 ;
25661 int res1 = 0 ;
25662 PyObject *swig_obj[1] ;
25663
25664 if (!args) SWIG_fail;
25665 swig_obj[0] = args;
25666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25667 if (!SWIG_IsOK(res1)) {
25668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25669 }
25670 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25671 {
25672 PyThreadState* __tstate = wxPyBeginAllowThreads();
25673 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25674 wxPyEndAllowThreads(__tstate);
25675 if (PyErr_Occurred()) SWIG_fail;
25676 }
25677 {
25678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25679 }
25680 return resultobj;
25681 fail:
25682 return NULL;
25683 }
25684
25685
25686 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25687 PyObject *resultobj = 0;
25688 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25689 bool arg2 ;
25690 void *argp1 = 0 ;
25691 int res1 = 0 ;
25692 bool val2 ;
25693 int ecode2 = 0 ;
25694 PyObject * obj0 = 0 ;
25695 PyObject * obj1 = 0 ;
25696 char * kwnames[] = {
25697 (char *) "self",(char *) "bIs", NULL
25698 };
25699
25700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25702 if (!SWIG_IsOK(res1)) {
25703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25704 }
25705 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25706 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25707 if (!SWIG_IsOK(ecode2)) {
25708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25709 }
25710 arg2 = static_cast< bool >(val2);
25711 {
25712 PyThreadState* __tstate = wxPyBeginAllowThreads();
25713 (arg1)->SetFromTab(arg2);
25714 wxPyEndAllowThreads(__tstate);
25715 if (PyErr_Occurred()) SWIG_fail;
25716 }
25717 resultobj = SWIG_Py_Void();
25718 return resultobj;
25719 fail:
25720 return NULL;
25721 }
25722
25723
25724 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25725 PyObject *resultobj = 0;
25726 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25727 long arg2 ;
25728 void *argp1 = 0 ;
25729 int res1 = 0 ;
25730 long val2 ;
25731 int ecode2 = 0 ;
25732 PyObject * obj0 = 0 ;
25733 PyObject * obj1 = 0 ;
25734 char * kwnames[] = {
25735 (char *) "self",(char *) "flags", NULL
25736 };
25737
25738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25740 if (!SWIG_IsOK(res1)) {
25741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25742 }
25743 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25744 ecode2 = SWIG_AsVal_long(obj1, &val2);
25745 if (!SWIG_IsOK(ecode2)) {
25746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25747 }
25748 arg2 = static_cast< long >(val2);
25749 {
25750 PyThreadState* __tstate = wxPyBeginAllowThreads();
25751 (arg1)->SetFlags(arg2);
25752 wxPyEndAllowThreads(__tstate);
25753 if (PyErr_Occurred()) SWIG_fail;
25754 }
25755 resultobj = SWIG_Py_Void();
25756 return resultobj;
25757 fail:
25758 return NULL;
25759 }
25760
25761
25762 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25763 PyObject *resultobj = 0;
25764 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25765 wxWindow *result = 0 ;
25766 void *argp1 = 0 ;
25767 int res1 = 0 ;
25768 PyObject *swig_obj[1] ;
25769
25770 if (!args) SWIG_fail;
25771 swig_obj[0] = args;
25772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25773 if (!SWIG_IsOK(res1)) {
25774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25775 }
25776 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25777 {
25778 PyThreadState* __tstate = wxPyBeginAllowThreads();
25779 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25780 wxPyEndAllowThreads(__tstate);
25781 if (PyErr_Occurred()) SWIG_fail;
25782 }
25783 {
25784 resultobj = wxPyMake_wxObject(result, (bool)0);
25785 }
25786 return resultobj;
25787 fail:
25788 return NULL;
25789 }
25790
25791
25792 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25793 PyObject *resultobj = 0;
25794 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25795 wxWindow *arg2 = (wxWindow *) 0 ;
25796 void *argp1 = 0 ;
25797 int res1 = 0 ;
25798 void *argp2 = 0 ;
25799 int res2 = 0 ;
25800 PyObject * obj0 = 0 ;
25801 PyObject * obj1 = 0 ;
25802 char * kwnames[] = {
25803 (char *) "self",(char *) "win", NULL
25804 };
25805
25806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25808 if (!SWIG_IsOK(res1)) {
25809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25810 }
25811 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25813 if (!SWIG_IsOK(res2)) {
25814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25815 }
25816 arg2 = reinterpret_cast< wxWindow * >(argp2);
25817 {
25818 PyThreadState* __tstate = wxPyBeginAllowThreads();
25819 (arg1)->SetCurrentFocus(arg2);
25820 wxPyEndAllowThreads(__tstate);
25821 if (PyErr_Occurred()) SWIG_fail;
25822 }
25823 resultobj = SWIG_Py_Void();
25824 return resultobj;
25825 fail:
25826 return NULL;
25827 }
25828
25829
25830 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25831 PyObject *obj;
25832 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25833 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25834 return SWIG_Py_Void();
25835 }
25836
25837 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25838 return SWIG_Python_InitShadowInstance(args);
25839 }
25840
25841 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25842 PyObject *resultobj = 0;
25843 wxWindow *arg1 = (wxWindow *) NULL ;
25844 wxWindowCreateEvent *result = 0 ;
25845 void *argp1 = 0 ;
25846 int res1 = 0 ;
25847 PyObject * obj0 = 0 ;
25848 char * kwnames[] = {
25849 (char *) "win", NULL
25850 };
25851
25852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25853 if (obj0) {
25854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25855 if (!SWIG_IsOK(res1)) {
25856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25857 }
25858 arg1 = reinterpret_cast< wxWindow * >(argp1);
25859 }
25860 {
25861 PyThreadState* __tstate = wxPyBeginAllowThreads();
25862 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25863 wxPyEndAllowThreads(__tstate);
25864 if (PyErr_Occurred()) SWIG_fail;
25865 }
25866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25867 return resultobj;
25868 fail:
25869 return NULL;
25870 }
25871
25872
25873 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25874 PyObject *resultobj = 0;
25875 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25876 wxWindow *result = 0 ;
25877 void *argp1 = 0 ;
25878 int res1 = 0 ;
25879 PyObject *swig_obj[1] ;
25880
25881 if (!args) SWIG_fail;
25882 swig_obj[0] = args;
25883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25884 if (!SWIG_IsOK(res1)) {
25885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25886 }
25887 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25888 {
25889 PyThreadState* __tstate = wxPyBeginAllowThreads();
25890 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25891 wxPyEndAllowThreads(__tstate);
25892 if (PyErr_Occurred()) SWIG_fail;
25893 }
25894 {
25895 resultobj = wxPyMake_wxObject(result, (bool)0);
25896 }
25897 return resultobj;
25898 fail:
25899 return NULL;
25900 }
25901
25902
25903 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25904 PyObject *obj;
25905 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25906 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25907 return SWIG_Py_Void();
25908 }
25909
25910 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25911 return SWIG_Python_InitShadowInstance(args);
25912 }
25913
25914 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25915 PyObject *resultobj = 0;
25916 wxWindow *arg1 = (wxWindow *) NULL ;
25917 wxWindowDestroyEvent *result = 0 ;
25918 void *argp1 = 0 ;
25919 int res1 = 0 ;
25920 PyObject * obj0 = 0 ;
25921 char * kwnames[] = {
25922 (char *) "win", NULL
25923 };
25924
25925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25926 if (obj0) {
25927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25928 if (!SWIG_IsOK(res1)) {
25929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25930 }
25931 arg1 = reinterpret_cast< wxWindow * >(argp1);
25932 }
25933 {
25934 PyThreadState* __tstate = wxPyBeginAllowThreads();
25935 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
25936 wxPyEndAllowThreads(__tstate);
25937 if (PyErr_Occurred()) SWIG_fail;
25938 }
25939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
25940 return resultobj;
25941 fail:
25942 return NULL;
25943 }
25944
25945
25946 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25947 PyObject *resultobj = 0;
25948 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
25949 wxWindow *result = 0 ;
25950 void *argp1 = 0 ;
25951 int res1 = 0 ;
25952 PyObject *swig_obj[1] ;
25953
25954 if (!args) SWIG_fail;
25955 swig_obj[0] = args;
25956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
25957 if (!SWIG_IsOK(res1)) {
25958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
25959 }
25960 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
25961 {
25962 PyThreadState* __tstate = wxPyBeginAllowThreads();
25963 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
25964 wxPyEndAllowThreads(__tstate);
25965 if (PyErr_Occurred()) SWIG_fail;
25966 }
25967 {
25968 resultobj = wxPyMake_wxObject(result, (bool)0);
25969 }
25970 return resultobj;
25971 fail:
25972 return NULL;
25973 }
25974
25975
25976 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25977 PyObject *obj;
25978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25979 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
25980 return SWIG_Py_Void();
25981 }
25982
25983 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25984 return SWIG_Python_InitShadowInstance(args);
25985 }
25986
25987 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25988 PyObject *resultobj = 0;
25989 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
25990 int arg2 = (int) 0 ;
25991 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25992 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25993 wxContextMenuEvent *result = 0 ;
25994 int val1 ;
25995 int ecode1 = 0 ;
25996 int val2 ;
25997 int ecode2 = 0 ;
25998 wxPoint temp3 ;
25999 PyObject * obj0 = 0 ;
26000 PyObject * obj1 = 0 ;
26001 PyObject * obj2 = 0 ;
26002 char * kwnames[] = {
26003 (char *) "type",(char *) "winid",(char *) "pt", NULL
26004 };
26005
26006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26007 if (obj0) {
26008 ecode1 = SWIG_AsVal_int(obj0, &val1);
26009 if (!SWIG_IsOK(ecode1)) {
26010 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26011 }
26012 arg1 = static_cast< wxEventType >(val1);
26013 }
26014 if (obj1) {
26015 ecode2 = SWIG_AsVal_int(obj1, &val2);
26016 if (!SWIG_IsOK(ecode2)) {
26017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26018 }
26019 arg2 = static_cast< int >(val2);
26020 }
26021 if (obj2) {
26022 {
26023 arg3 = &temp3;
26024 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26025 }
26026 }
26027 {
26028 PyThreadState* __tstate = wxPyBeginAllowThreads();
26029 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26030 wxPyEndAllowThreads(__tstate);
26031 if (PyErr_Occurred()) SWIG_fail;
26032 }
26033 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26034 return resultobj;
26035 fail:
26036 return NULL;
26037 }
26038
26039
26040 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26041 PyObject *resultobj = 0;
26042 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26043 wxPoint *result = 0 ;
26044 void *argp1 = 0 ;
26045 int res1 = 0 ;
26046 PyObject *swig_obj[1] ;
26047
26048 if (!args) SWIG_fail;
26049 swig_obj[0] = args;
26050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26051 if (!SWIG_IsOK(res1)) {
26052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26053 }
26054 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26055 {
26056 PyThreadState* __tstate = wxPyBeginAllowThreads();
26057 {
26058 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26059 result = (wxPoint *) &_result_ref;
26060 }
26061 wxPyEndAllowThreads(__tstate);
26062 if (PyErr_Occurred()) SWIG_fail;
26063 }
26064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26065 return resultobj;
26066 fail:
26067 return NULL;
26068 }
26069
26070
26071 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26072 PyObject *resultobj = 0;
26073 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26074 wxPoint *arg2 = 0 ;
26075 void *argp1 = 0 ;
26076 int res1 = 0 ;
26077 wxPoint temp2 ;
26078 PyObject * obj0 = 0 ;
26079 PyObject * obj1 = 0 ;
26080 char * kwnames[] = {
26081 (char *) "self",(char *) "pos", NULL
26082 };
26083
26084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26086 if (!SWIG_IsOK(res1)) {
26087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26088 }
26089 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26090 {
26091 arg2 = &temp2;
26092 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26093 }
26094 {
26095 PyThreadState* __tstate = wxPyBeginAllowThreads();
26096 (arg1)->SetPosition((wxPoint const &)*arg2);
26097 wxPyEndAllowThreads(__tstate);
26098 if (PyErr_Occurred()) SWIG_fail;
26099 }
26100 resultobj = SWIG_Py_Void();
26101 return resultobj;
26102 fail:
26103 return NULL;
26104 }
26105
26106
26107 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26108 PyObject *obj;
26109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26110 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26111 return SWIG_Py_Void();
26112 }
26113
26114 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26115 return SWIG_Python_InitShadowInstance(args);
26116 }
26117
26118 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26119 PyObject *resultobj = 0;
26120 wxIdleEvent *result = 0 ;
26121
26122 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26123 {
26124 PyThreadState* __tstate = wxPyBeginAllowThreads();
26125 result = (wxIdleEvent *)new wxIdleEvent();
26126 wxPyEndAllowThreads(__tstate);
26127 if (PyErr_Occurred()) SWIG_fail;
26128 }
26129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26130 return resultobj;
26131 fail:
26132 return NULL;
26133 }
26134
26135
26136 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26137 PyObject *resultobj = 0;
26138 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26139 bool arg2 = (bool) true ;
26140 void *argp1 = 0 ;
26141 int res1 = 0 ;
26142 bool val2 ;
26143 int ecode2 = 0 ;
26144 PyObject * obj0 = 0 ;
26145 PyObject * obj1 = 0 ;
26146 char * kwnames[] = {
26147 (char *) "self",(char *) "needMore", NULL
26148 };
26149
26150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26152 if (!SWIG_IsOK(res1)) {
26153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26154 }
26155 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26156 if (obj1) {
26157 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26158 if (!SWIG_IsOK(ecode2)) {
26159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26160 }
26161 arg2 = static_cast< bool >(val2);
26162 }
26163 {
26164 PyThreadState* __tstate = wxPyBeginAllowThreads();
26165 (arg1)->RequestMore(arg2);
26166 wxPyEndAllowThreads(__tstate);
26167 if (PyErr_Occurred()) SWIG_fail;
26168 }
26169 resultobj = SWIG_Py_Void();
26170 return resultobj;
26171 fail:
26172 return NULL;
26173 }
26174
26175
26176 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26177 PyObject *resultobj = 0;
26178 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26179 bool result;
26180 void *argp1 = 0 ;
26181 int res1 = 0 ;
26182 PyObject *swig_obj[1] ;
26183
26184 if (!args) SWIG_fail;
26185 swig_obj[0] = args;
26186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26187 if (!SWIG_IsOK(res1)) {
26188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26189 }
26190 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26191 {
26192 PyThreadState* __tstate = wxPyBeginAllowThreads();
26193 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26194 wxPyEndAllowThreads(__tstate);
26195 if (PyErr_Occurred()) SWIG_fail;
26196 }
26197 {
26198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26199 }
26200 return resultobj;
26201 fail:
26202 return NULL;
26203 }
26204
26205
26206 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26207 PyObject *resultobj = 0;
26208 wxIdleMode arg1 ;
26209 int val1 ;
26210 int ecode1 = 0 ;
26211 PyObject * obj0 = 0 ;
26212 char * kwnames[] = {
26213 (char *) "mode", NULL
26214 };
26215
26216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26217 ecode1 = SWIG_AsVal_int(obj0, &val1);
26218 if (!SWIG_IsOK(ecode1)) {
26219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26220 }
26221 arg1 = static_cast< wxIdleMode >(val1);
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 wxIdleEvent::SetMode(arg1);
26225 wxPyEndAllowThreads(__tstate);
26226 if (PyErr_Occurred()) SWIG_fail;
26227 }
26228 resultobj = SWIG_Py_Void();
26229 return resultobj;
26230 fail:
26231 return NULL;
26232 }
26233
26234
26235 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26236 PyObject *resultobj = 0;
26237 wxIdleMode result;
26238
26239 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26240 {
26241 PyThreadState* __tstate = wxPyBeginAllowThreads();
26242 result = (wxIdleMode)wxIdleEvent::GetMode();
26243 wxPyEndAllowThreads(__tstate);
26244 if (PyErr_Occurred()) SWIG_fail;
26245 }
26246 resultobj = SWIG_From_int(static_cast< int >(result));
26247 return resultobj;
26248 fail:
26249 return NULL;
26250 }
26251
26252
26253 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26254 PyObject *resultobj = 0;
26255 wxWindow *arg1 = (wxWindow *) 0 ;
26256 bool result;
26257 void *argp1 = 0 ;
26258 int res1 = 0 ;
26259 PyObject * obj0 = 0 ;
26260 char * kwnames[] = {
26261 (char *) "win", NULL
26262 };
26263
26264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26266 if (!SWIG_IsOK(res1)) {
26267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26268 }
26269 arg1 = reinterpret_cast< wxWindow * >(argp1);
26270 {
26271 PyThreadState* __tstate = wxPyBeginAllowThreads();
26272 result = (bool)wxIdleEvent::CanSend(arg1);
26273 wxPyEndAllowThreads(__tstate);
26274 if (PyErr_Occurred()) SWIG_fail;
26275 }
26276 {
26277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26278 }
26279 return resultobj;
26280 fail:
26281 return NULL;
26282 }
26283
26284
26285 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26286 PyObject *obj;
26287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26288 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26289 return SWIG_Py_Void();
26290 }
26291
26292 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26293 return SWIG_Python_InitShadowInstance(args);
26294 }
26295
26296 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26297 PyObject *resultobj = 0;
26298 int arg1 = (int) 0 ;
26299 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26300 wxPyEvent *result = 0 ;
26301 int val1 ;
26302 int ecode1 = 0 ;
26303 int val2 ;
26304 int ecode2 = 0 ;
26305 PyObject * obj0 = 0 ;
26306 PyObject * obj1 = 0 ;
26307 char * kwnames[] = {
26308 (char *) "winid",(char *) "eventType", NULL
26309 };
26310
26311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26312 if (obj0) {
26313 ecode1 = SWIG_AsVal_int(obj0, &val1);
26314 if (!SWIG_IsOK(ecode1)) {
26315 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26316 }
26317 arg1 = static_cast< int >(val1);
26318 }
26319 if (obj1) {
26320 ecode2 = SWIG_AsVal_int(obj1, &val2);
26321 if (!SWIG_IsOK(ecode2)) {
26322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26323 }
26324 arg2 = static_cast< wxEventType >(val2);
26325 }
26326 {
26327 PyThreadState* __tstate = wxPyBeginAllowThreads();
26328 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26329 wxPyEndAllowThreads(__tstate);
26330 if (PyErr_Occurred()) SWIG_fail;
26331 }
26332 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26333 return resultobj;
26334 fail:
26335 return NULL;
26336 }
26337
26338
26339 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26340 PyObject *resultobj = 0;
26341 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26342 void *argp1 = 0 ;
26343 int res1 = 0 ;
26344 PyObject *swig_obj[1] ;
26345
26346 if (!args) SWIG_fail;
26347 swig_obj[0] = args;
26348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26349 if (!SWIG_IsOK(res1)) {
26350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26351 }
26352 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26353 {
26354 PyThreadState* __tstate = wxPyBeginAllowThreads();
26355 delete arg1;
26356
26357 wxPyEndAllowThreads(__tstate);
26358 if (PyErr_Occurred()) SWIG_fail;
26359 }
26360 resultobj = SWIG_Py_Void();
26361 return resultobj;
26362 fail:
26363 return NULL;
26364 }
26365
26366
26367 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26368 PyObject *resultobj = 0;
26369 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26370 PyObject *arg2 = (PyObject *) 0 ;
26371 void *argp1 = 0 ;
26372 int res1 = 0 ;
26373 PyObject * obj0 = 0 ;
26374 PyObject * obj1 = 0 ;
26375 char * kwnames[] = {
26376 (char *) "self",(char *) "self", NULL
26377 };
26378
26379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26381 if (!SWIG_IsOK(res1)) {
26382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26383 }
26384 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26385 arg2 = obj1;
26386 {
26387 PyThreadState* __tstate = wxPyBeginAllowThreads();
26388 (arg1)->SetSelf(arg2);
26389 wxPyEndAllowThreads(__tstate);
26390 if (PyErr_Occurred()) SWIG_fail;
26391 }
26392 resultobj = SWIG_Py_Void();
26393 return resultobj;
26394 fail:
26395 return NULL;
26396 }
26397
26398
26399 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26400 PyObject *resultobj = 0;
26401 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26402 PyObject *result = 0 ;
26403 void *argp1 = 0 ;
26404 int res1 = 0 ;
26405 PyObject *swig_obj[1] ;
26406
26407 if (!args) SWIG_fail;
26408 swig_obj[0] = args;
26409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26410 if (!SWIG_IsOK(res1)) {
26411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26412 }
26413 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26414 {
26415 PyThreadState* __tstate = wxPyBeginAllowThreads();
26416 result = (PyObject *)(arg1)->GetSelf();
26417 wxPyEndAllowThreads(__tstate);
26418 if (PyErr_Occurred()) SWIG_fail;
26419 }
26420 resultobj = result;
26421 return resultobj;
26422 fail:
26423 return NULL;
26424 }
26425
26426
26427 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26428 PyObject *obj;
26429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26430 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26431 return SWIG_Py_Void();
26432 }
26433
26434 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26435 return SWIG_Python_InitShadowInstance(args);
26436 }
26437
26438 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26439 PyObject *resultobj = 0;
26440 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26441 int arg2 = (int) 0 ;
26442 wxPyCommandEvent *result = 0 ;
26443 int val1 ;
26444 int ecode1 = 0 ;
26445 int val2 ;
26446 int ecode2 = 0 ;
26447 PyObject * obj0 = 0 ;
26448 PyObject * obj1 = 0 ;
26449 char * kwnames[] = {
26450 (char *) "eventType",(char *) "id", NULL
26451 };
26452
26453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26454 if (obj0) {
26455 ecode1 = SWIG_AsVal_int(obj0, &val1);
26456 if (!SWIG_IsOK(ecode1)) {
26457 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26458 }
26459 arg1 = static_cast< wxEventType >(val1);
26460 }
26461 if (obj1) {
26462 ecode2 = SWIG_AsVal_int(obj1, &val2);
26463 if (!SWIG_IsOK(ecode2)) {
26464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26465 }
26466 arg2 = static_cast< int >(val2);
26467 }
26468 {
26469 PyThreadState* __tstate = wxPyBeginAllowThreads();
26470 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26471 wxPyEndAllowThreads(__tstate);
26472 if (PyErr_Occurred()) SWIG_fail;
26473 }
26474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26475 return resultobj;
26476 fail:
26477 return NULL;
26478 }
26479
26480
26481 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26482 PyObject *resultobj = 0;
26483 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26484 void *argp1 = 0 ;
26485 int res1 = 0 ;
26486 PyObject *swig_obj[1] ;
26487
26488 if (!args) SWIG_fail;
26489 swig_obj[0] = args;
26490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26491 if (!SWIG_IsOK(res1)) {
26492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26493 }
26494 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26495 {
26496 PyThreadState* __tstate = wxPyBeginAllowThreads();
26497 delete arg1;
26498
26499 wxPyEndAllowThreads(__tstate);
26500 if (PyErr_Occurred()) SWIG_fail;
26501 }
26502 resultobj = SWIG_Py_Void();
26503 return resultobj;
26504 fail:
26505 return NULL;
26506 }
26507
26508
26509 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26510 PyObject *resultobj = 0;
26511 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26512 PyObject *arg2 = (PyObject *) 0 ;
26513 void *argp1 = 0 ;
26514 int res1 = 0 ;
26515 PyObject * obj0 = 0 ;
26516 PyObject * obj1 = 0 ;
26517 char * kwnames[] = {
26518 (char *) "self",(char *) "self", NULL
26519 };
26520
26521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26523 if (!SWIG_IsOK(res1)) {
26524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26525 }
26526 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26527 arg2 = obj1;
26528 {
26529 PyThreadState* __tstate = wxPyBeginAllowThreads();
26530 (arg1)->SetSelf(arg2);
26531 wxPyEndAllowThreads(__tstate);
26532 if (PyErr_Occurred()) SWIG_fail;
26533 }
26534 resultobj = SWIG_Py_Void();
26535 return resultobj;
26536 fail:
26537 return NULL;
26538 }
26539
26540
26541 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26542 PyObject *resultobj = 0;
26543 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26544 PyObject *result = 0 ;
26545 void *argp1 = 0 ;
26546 int res1 = 0 ;
26547 PyObject *swig_obj[1] ;
26548
26549 if (!args) SWIG_fail;
26550 swig_obj[0] = args;
26551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26552 if (!SWIG_IsOK(res1)) {
26553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26554 }
26555 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26556 {
26557 PyThreadState* __tstate = wxPyBeginAllowThreads();
26558 result = (PyObject *)(arg1)->GetSelf();
26559 wxPyEndAllowThreads(__tstate);
26560 if (PyErr_Occurred()) SWIG_fail;
26561 }
26562 resultobj = result;
26563 return resultobj;
26564 fail:
26565 return NULL;
26566 }
26567
26568
26569 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26570 PyObject *obj;
26571 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26572 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26573 return SWIG_Py_Void();
26574 }
26575
26576 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26577 return SWIG_Python_InitShadowInstance(args);
26578 }
26579
26580 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26581 PyObject *resultobj = 0;
26582 wxWindow *arg1 = (wxWindow *) 0 ;
26583 wxDateTime *arg2 = 0 ;
26584 wxEventType arg3 ;
26585 wxDateEvent *result = 0 ;
26586 void *argp1 = 0 ;
26587 int res1 = 0 ;
26588 void *argp2 = 0 ;
26589 int res2 = 0 ;
26590 int val3 ;
26591 int ecode3 = 0 ;
26592 PyObject * obj0 = 0 ;
26593 PyObject * obj1 = 0 ;
26594 PyObject * obj2 = 0 ;
26595 char * kwnames[] = {
26596 (char *) "win",(char *) "dt",(char *) "type", NULL
26597 };
26598
26599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26601 if (!SWIG_IsOK(res1)) {
26602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26603 }
26604 arg1 = reinterpret_cast< wxWindow * >(argp1);
26605 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26606 if (!SWIG_IsOK(res2)) {
26607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26608 }
26609 if (!argp2) {
26610 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26611 }
26612 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26613 ecode3 = SWIG_AsVal_int(obj2, &val3);
26614 if (!SWIG_IsOK(ecode3)) {
26615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26616 }
26617 arg3 = static_cast< wxEventType >(val3);
26618 {
26619 PyThreadState* __tstate = wxPyBeginAllowThreads();
26620 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26621 wxPyEndAllowThreads(__tstate);
26622 if (PyErr_Occurred()) SWIG_fail;
26623 }
26624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26625 return resultobj;
26626 fail:
26627 return NULL;
26628 }
26629
26630
26631 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26632 PyObject *resultobj = 0;
26633 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26634 wxDateTime *result = 0 ;
26635 void *argp1 = 0 ;
26636 int res1 = 0 ;
26637 PyObject *swig_obj[1] ;
26638
26639 if (!args) SWIG_fail;
26640 swig_obj[0] = args;
26641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26642 if (!SWIG_IsOK(res1)) {
26643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26644 }
26645 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26646 {
26647 PyThreadState* __tstate = wxPyBeginAllowThreads();
26648 {
26649 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26650 result = (wxDateTime *) &_result_ref;
26651 }
26652 wxPyEndAllowThreads(__tstate);
26653 if (PyErr_Occurred()) SWIG_fail;
26654 }
26655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26656 return resultobj;
26657 fail:
26658 return NULL;
26659 }
26660
26661
26662 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26663 PyObject *resultobj = 0;
26664 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26665 wxDateTime *arg2 = 0 ;
26666 void *argp1 = 0 ;
26667 int res1 = 0 ;
26668 void *argp2 = 0 ;
26669 int res2 = 0 ;
26670 PyObject * obj0 = 0 ;
26671 PyObject * obj1 = 0 ;
26672 char * kwnames[] = {
26673 (char *) "self",(char *) "date", NULL
26674 };
26675
26676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26678 if (!SWIG_IsOK(res1)) {
26679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26680 }
26681 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26682 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26683 if (!SWIG_IsOK(res2)) {
26684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26685 }
26686 if (!argp2) {
26687 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26688 }
26689 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26690 {
26691 PyThreadState* __tstate = wxPyBeginAllowThreads();
26692 (arg1)->SetDate((wxDateTime const &)*arg2);
26693 wxPyEndAllowThreads(__tstate);
26694 if (PyErr_Occurred()) SWIG_fail;
26695 }
26696 resultobj = SWIG_Py_Void();
26697 return resultobj;
26698 fail:
26699 return NULL;
26700 }
26701
26702
26703 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26704 PyObject *obj;
26705 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26706 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26707 return SWIG_Py_Void();
26708 }
26709
26710 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26711 return SWIG_Python_InitShadowInstance(args);
26712 }
26713
26714 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26715 PyObject *resultobj = 0;
26716 wxPyApp *result = 0 ;
26717
26718 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26719 {
26720 PyThreadState* __tstate = wxPyBeginAllowThreads();
26721 result = (wxPyApp *)new_wxPyApp();
26722 wxPyEndAllowThreads(__tstate);
26723 if (PyErr_Occurred()) SWIG_fail;
26724 }
26725 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26726 return resultobj;
26727 fail:
26728 return NULL;
26729 }
26730
26731
26732 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26733 PyObject *resultobj = 0;
26734 wxPyApp *arg1 = (wxPyApp *) 0 ;
26735 void *argp1 = 0 ;
26736 int res1 = 0 ;
26737 PyObject *swig_obj[1] ;
26738
26739 if (!args) SWIG_fail;
26740 swig_obj[0] = args;
26741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26742 if (!SWIG_IsOK(res1)) {
26743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26744 }
26745 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26746 {
26747 PyThreadState* __tstate = wxPyBeginAllowThreads();
26748 delete arg1;
26749
26750 wxPyEndAllowThreads(__tstate);
26751 if (PyErr_Occurred()) SWIG_fail;
26752 }
26753 resultobj = SWIG_Py_Void();
26754 return resultobj;
26755 fail:
26756 return NULL;
26757 }
26758
26759
26760 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26761 PyObject *resultobj = 0;
26762 wxPyApp *arg1 = (wxPyApp *) 0 ;
26763 PyObject *arg2 = (PyObject *) 0 ;
26764 PyObject *arg3 = (PyObject *) 0 ;
26765 bool arg4 ;
26766 void *argp1 = 0 ;
26767 int res1 = 0 ;
26768 bool val4 ;
26769 int ecode4 = 0 ;
26770 PyObject * obj0 = 0 ;
26771 PyObject * obj1 = 0 ;
26772 PyObject * obj2 = 0 ;
26773 PyObject * obj3 = 0 ;
26774 char * kwnames[] = {
26775 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26776 };
26777
26778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26780 if (!SWIG_IsOK(res1)) {
26781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26782 }
26783 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26784 arg2 = obj1;
26785 arg3 = obj2;
26786 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26787 if (!SWIG_IsOK(ecode4)) {
26788 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26789 }
26790 arg4 = static_cast< bool >(val4);
26791 {
26792 PyThreadState* __tstate = wxPyBeginAllowThreads();
26793 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26794 wxPyEndAllowThreads(__tstate);
26795 if (PyErr_Occurred()) SWIG_fail;
26796 }
26797 resultobj = SWIG_Py_Void();
26798 return resultobj;
26799 fail:
26800 return NULL;
26801 }
26802
26803
26804 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26805 PyObject *resultobj = 0;
26806 wxPyApp *arg1 = (wxPyApp *) 0 ;
26807 wxString result;
26808 void *argp1 = 0 ;
26809 int res1 = 0 ;
26810 PyObject *swig_obj[1] ;
26811
26812 if (!args) SWIG_fail;
26813 swig_obj[0] = args;
26814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26815 if (!SWIG_IsOK(res1)) {
26816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26817 }
26818 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26819 {
26820 PyThreadState* __tstate = wxPyBeginAllowThreads();
26821 result = ((wxPyApp const *)arg1)->GetAppName();
26822 wxPyEndAllowThreads(__tstate);
26823 if (PyErr_Occurred()) SWIG_fail;
26824 }
26825 {
26826 #if wxUSE_UNICODE
26827 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26828 #else
26829 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26830 #endif
26831 }
26832 return resultobj;
26833 fail:
26834 return NULL;
26835 }
26836
26837
26838 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26839 PyObject *resultobj = 0;
26840 wxPyApp *arg1 = (wxPyApp *) 0 ;
26841 wxString *arg2 = 0 ;
26842 void *argp1 = 0 ;
26843 int res1 = 0 ;
26844 bool temp2 = false ;
26845 PyObject * obj0 = 0 ;
26846 PyObject * obj1 = 0 ;
26847 char * kwnames[] = {
26848 (char *) "self",(char *) "name", NULL
26849 };
26850
26851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26853 if (!SWIG_IsOK(res1)) {
26854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26855 }
26856 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26857 {
26858 arg2 = wxString_in_helper(obj1);
26859 if (arg2 == NULL) SWIG_fail;
26860 temp2 = true;
26861 }
26862 {
26863 PyThreadState* __tstate = wxPyBeginAllowThreads();
26864 (arg1)->SetAppName((wxString const &)*arg2);
26865 wxPyEndAllowThreads(__tstate);
26866 if (PyErr_Occurred()) SWIG_fail;
26867 }
26868 resultobj = SWIG_Py_Void();
26869 {
26870 if (temp2)
26871 delete arg2;
26872 }
26873 return resultobj;
26874 fail:
26875 {
26876 if (temp2)
26877 delete arg2;
26878 }
26879 return NULL;
26880 }
26881
26882
26883 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26884 PyObject *resultobj = 0;
26885 wxPyApp *arg1 = (wxPyApp *) 0 ;
26886 wxString result;
26887 void *argp1 = 0 ;
26888 int res1 = 0 ;
26889 PyObject *swig_obj[1] ;
26890
26891 if (!args) SWIG_fail;
26892 swig_obj[0] = args;
26893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26894 if (!SWIG_IsOK(res1)) {
26895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26896 }
26897 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26898 {
26899 PyThreadState* __tstate = wxPyBeginAllowThreads();
26900 result = ((wxPyApp const *)arg1)->GetClassName();
26901 wxPyEndAllowThreads(__tstate);
26902 if (PyErr_Occurred()) SWIG_fail;
26903 }
26904 {
26905 #if wxUSE_UNICODE
26906 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26907 #else
26908 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26909 #endif
26910 }
26911 return resultobj;
26912 fail:
26913 return NULL;
26914 }
26915
26916
26917 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26918 PyObject *resultobj = 0;
26919 wxPyApp *arg1 = (wxPyApp *) 0 ;
26920 wxString *arg2 = 0 ;
26921 void *argp1 = 0 ;
26922 int res1 = 0 ;
26923 bool temp2 = false ;
26924 PyObject * obj0 = 0 ;
26925 PyObject * obj1 = 0 ;
26926 char * kwnames[] = {
26927 (char *) "self",(char *) "name", NULL
26928 };
26929
26930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
26931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26932 if (!SWIG_IsOK(res1)) {
26933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26934 }
26935 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26936 {
26937 arg2 = wxString_in_helper(obj1);
26938 if (arg2 == NULL) SWIG_fail;
26939 temp2 = true;
26940 }
26941 {
26942 PyThreadState* __tstate = wxPyBeginAllowThreads();
26943 (arg1)->SetClassName((wxString const &)*arg2);
26944 wxPyEndAllowThreads(__tstate);
26945 if (PyErr_Occurred()) SWIG_fail;
26946 }
26947 resultobj = SWIG_Py_Void();
26948 {
26949 if (temp2)
26950 delete arg2;
26951 }
26952 return resultobj;
26953 fail:
26954 {
26955 if (temp2)
26956 delete arg2;
26957 }
26958 return NULL;
26959 }
26960
26961
26962 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26963 PyObject *resultobj = 0;
26964 wxPyApp *arg1 = (wxPyApp *) 0 ;
26965 wxString *result = 0 ;
26966 void *argp1 = 0 ;
26967 int res1 = 0 ;
26968 PyObject *swig_obj[1] ;
26969
26970 if (!args) SWIG_fail;
26971 swig_obj[0] = args;
26972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26973 if (!SWIG_IsOK(res1)) {
26974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26975 }
26976 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26977 {
26978 PyThreadState* __tstate = wxPyBeginAllowThreads();
26979 {
26980 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
26981 result = (wxString *) &_result_ref;
26982 }
26983 wxPyEndAllowThreads(__tstate);
26984 if (PyErr_Occurred()) SWIG_fail;
26985 }
26986 {
26987 #if wxUSE_UNICODE
26988 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
26989 #else
26990 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
26991 #endif
26992 }
26993 return resultobj;
26994 fail:
26995 return NULL;
26996 }
26997
26998
26999 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27000 PyObject *resultobj = 0;
27001 wxPyApp *arg1 = (wxPyApp *) 0 ;
27002 wxString *arg2 = 0 ;
27003 void *argp1 = 0 ;
27004 int res1 = 0 ;
27005 bool temp2 = false ;
27006 PyObject * obj0 = 0 ;
27007 PyObject * obj1 = 0 ;
27008 char * kwnames[] = {
27009 (char *) "self",(char *) "name", NULL
27010 };
27011
27012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27014 if (!SWIG_IsOK(res1)) {
27015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27016 }
27017 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27018 {
27019 arg2 = wxString_in_helper(obj1);
27020 if (arg2 == NULL) SWIG_fail;
27021 temp2 = true;
27022 }
27023 {
27024 PyThreadState* __tstate = wxPyBeginAllowThreads();
27025 (arg1)->SetVendorName((wxString const &)*arg2);
27026 wxPyEndAllowThreads(__tstate);
27027 if (PyErr_Occurred()) SWIG_fail;
27028 }
27029 resultobj = SWIG_Py_Void();
27030 {
27031 if (temp2)
27032 delete arg2;
27033 }
27034 return resultobj;
27035 fail:
27036 {
27037 if (temp2)
27038 delete arg2;
27039 }
27040 return NULL;
27041 }
27042
27043
27044 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27045 PyObject *resultobj = 0;
27046 wxPyApp *arg1 = (wxPyApp *) 0 ;
27047 wxAppTraits *result = 0 ;
27048 void *argp1 = 0 ;
27049 int res1 = 0 ;
27050 PyObject *swig_obj[1] ;
27051
27052 if (!args) SWIG_fail;
27053 swig_obj[0] = args;
27054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27055 if (!SWIG_IsOK(res1)) {
27056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27057 }
27058 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27059 {
27060 PyThreadState* __tstate = wxPyBeginAllowThreads();
27061 result = (wxAppTraits *)(arg1)->GetTraits();
27062 wxPyEndAllowThreads(__tstate);
27063 if (PyErr_Occurred()) SWIG_fail;
27064 }
27065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27066 return resultobj;
27067 fail:
27068 return NULL;
27069 }
27070
27071
27072 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27073 PyObject *resultobj = 0;
27074 wxPyApp *arg1 = (wxPyApp *) 0 ;
27075 void *argp1 = 0 ;
27076 int res1 = 0 ;
27077 PyObject *swig_obj[1] ;
27078
27079 if (!args) SWIG_fail;
27080 swig_obj[0] = args;
27081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27082 if (!SWIG_IsOK(res1)) {
27083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27084 }
27085 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27086 {
27087 PyThreadState* __tstate = wxPyBeginAllowThreads();
27088 (arg1)->ProcessPendingEvents();
27089 wxPyEndAllowThreads(__tstate);
27090 if (PyErr_Occurred()) SWIG_fail;
27091 }
27092 resultobj = SWIG_Py_Void();
27093 return resultobj;
27094 fail:
27095 return NULL;
27096 }
27097
27098
27099 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27100 PyObject *resultobj = 0;
27101 wxPyApp *arg1 = (wxPyApp *) 0 ;
27102 bool arg2 = (bool) false ;
27103 bool result;
27104 void *argp1 = 0 ;
27105 int res1 = 0 ;
27106 bool val2 ;
27107 int ecode2 = 0 ;
27108 PyObject * obj0 = 0 ;
27109 PyObject * obj1 = 0 ;
27110 char * kwnames[] = {
27111 (char *) "self",(char *) "onlyIfNeeded", NULL
27112 };
27113
27114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27116 if (!SWIG_IsOK(res1)) {
27117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27118 }
27119 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27120 if (obj1) {
27121 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27122 if (!SWIG_IsOK(ecode2)) {
27123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27124 }
27125 arg2 = static_cast< bool >(val2);
27126 }
27127 {
27128 PyThreadState* __tstate = wxPyBeginAllowThreads();
27129 result = (bool)(arg1)->Yield(arg2);
27130 wxPyEndAllowThreads(__tstate);
27131 if (PyErr_Occurred()) SWIG_fail;
27132 }
27133 {
27134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27135 }
27136 return resultobj;
27137 fail:
27138 return NULL;
27139 }
27140
27141
27142 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27143 PyObject *resultobj = 0;
27144 wxPyApp *arg1 = (wxPyApp *) 0 ;
27145 void *argp1 = 0 ;
27146 int res1 = 0 ;
27147 PyObject *swig_obj[1] ;
27148
27149 if (!args) SWIG_fail;
27150 swig_obj[0] = args;
27151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27152 if (!SWIG_IsOK(res1)) {
27153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27154 }
27155 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27156 {
27157 PyThreadState* __tstate = wxPyBeginAllowThreads();
27158 (arg1)->WakeUpIdle();
27159 wxPyEndAllowThreads(__tstate);
27160 if (PyErr_Occurred()) SWIG_fail;
27161 }
27162 resultobj = SWIG_Py_Void();
27163 return resultobj;
27164 fail:
27165 return NULL;
27166 }
27167
27168
27169 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27170 PyObject *resultobj = 0;
27171 bool result;
27172
27173 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27174 {
27175 PyThreadState* __tstate = wxPyBeginAllowThreads();
27176 result = (bool)wxPyApp::IsMainLoopRunning();
27177 wxPyEndAllowThreads(__tstate);
27178 if (PyErr_Occurred()) SWIG_fail;
27179 }
27180 {
27181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27182 }
27183 return resultobj;
27184 fail:
27185 return NULL;
27186 }
27187
27188
27189 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27190 PyObject *resultobj = 0;
27191 wxPyApp *arg1 = (wxPyApp *) 0 ;
27192 int result;
27193 void *argp1 = 0 ;
27194 int res1 = 0 ;
27195 PyObject *swig_obj[1] ;
27196
27197 if (!args) SWIG_fail;
27198 swig_obj[0] = args;
27199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27200 if (!SWIG_IsOK(res1)) {
27201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27202 }
27203 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27204 {
27205 PyThreadState* __tstate = wxPyBeginAllowThreads();
27206 result = (int)(arg1)->MainLoop();
27207 wxPyEndAllowThreads(__tstate);
27208 if (PyErr_Occurred()) SWIG_fail;
27209 }
27210 resultobj = SWIG_From_int(static_cast< int >(result));
27211 return resultobj;
27212 fail:
27213 return NULL;
27214 }
27215
27216
27217 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27218 PyObject *resultobj = 0;
27219 wxPyApp *arg1 = (wxPyApp *) 0 ;
27220 void *argp1 = 0 ;
27221 int res1 = 0 ;
27222 PyObject *swig_obj[1] ;
27223
27224 if (!args) SWIG_fail;
27225 swig_obj[0] = args;
27226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27227 if (!SWIG_IsOK(res1)) {
27228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27229 }
27230 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27231 {
27232 PyThreadState* __tstate = wxPyBeginAllowThreads();
27233 (arg1)->Exit();
27234 wxPyEndAllowThreads(__tstate);
27235 if (PyErr_Occurred()) SWIG_fail;
27236 }
27237 resultobj = SWIG_Py_Void();
27238 return resultobj;
27239 fail:
27240 return NULL;
27241 }
27242
27243
27244 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27245 PyObject *resultobj = 0;
27246 wxPyApp *arg1 = (wxPyApp *) 0 ;
27247 void *argp1 = 0 ;
27248 int res1 = 0 ;
27249 PyObject *swig_obj[1] ;
27250
27251 if (!args) SWIG_fail;
27252 swig_obj[0] = args;
27253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27254 if (!SWIG_IsOK(res1)) {
27255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27256 }
27257 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27258 {
27259 PyThreadState* __tstate = wxPyBeginAllowThreads();
27260 (arg1)->ExitMainLoop();
27261 wxPyEndAllowThreads(__tstate);
27262 if (PyErr_Occurred()) SWIG_fail;
27263 }
27264 resultobj = SWIG_Py_Void();
27265 return resultobj;
27266 fail:
27267 return NULL;
27268 }
27269
27270
27271 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27272 PyObject *resultobj = 0;
27273 wxPyApp *arg1 = (wxPyApp *) 0 ;
27274 bool result;
27275 void *argp1 = 0 ;
27276 int res1 = 0 ;
27277 PyObject *swig_obj[1] ;
27278
27279 if (!args) SWIG_fail;
27280 swig_obj[0] = args;
27281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27282 if (!SWIG_IsOK(res1)) {
27283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27284 }
27285 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27286 {
27287 PyThreadState* __tstate = wxPyBeginAllowThreads();
27288 result = (bool)(arg1)->Pending();
27289 wxPyEndAllowThreads(__tstate);
27290 if (PyErr_Occurred()) SWIG_fail;
27291 }
27292 {
27293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27294 }
27295 return resultobj;
27296 fail:
27297 return NULL;
27298 }
27299
27300
27301 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27302 PyObject *resultobj = 0;
27303 wxPyApp *arg1 = (wxPyApp *) 0 ;
27304 bool result;
27305 void *argp1 = 0 ;
27306 int res1 = 0 ;
27307 PyObject *swig_obj[1] ;
27308
27309 if (!args) SWIG_fail;
27310 swig_obj[0] = args;
27311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27312 if (!SWIG_IsOK(res1)) {
27313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27314 }
27315 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27316 {
27317 PyThreadState* __tstate = wxPyBeginAllowThreads();
27318 result = (bool)(arg1)->Dispatch();
27319 wxPyEndAllowThreads(__tstate);
27320 if (PyErr_Occurred()) SWIG_fail;
27321 }
27322 {
27323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27324 }
27325 return resultobj;
27326 fail:
27327 return NULL;
27328 }
27329
27330
27331 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27332 PyObject *resultobj = 0;
27333 wxPyApp *arg1 = (wxPyApp *) 0 ;
27334 bool result;
27335 void *argp1 = 0 ;
27336 int res1 = 0 ;
27337 PyObject *swig_obj[1] ;
27338
27339 if (!args) SWIG_fail;
27340 swig_obj[0] = args;
27341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27342 if (!SWIG_IsOK(res1)) {
27343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27344 }
27345 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27346 {
27347 PyThreadState* __tstate = wxPyBeginAllowThreads();
27348 result = (bool)(arg1)->ProcessIdle();
27349 wxPyEndAllowThreads(__tstate);
27350 if (PyErr_Occurred()) SWIG_fail;
27351 }
27352 {
27353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27354 }
27355 return resultobj;
27356 fail:
27357 return NULL;
27358 }
27359
27360
27361 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27362 PyObject *resultobj = 0;
27363 wxPyApp *arg1 = (wxPyApp *) 0 ;
27364 wxWindow *arg2 = (wxWindow *) 0 ;
27365 wxIdleEvent *arg3 = 0 ;
27366 bool result;
27367 void *argp1 = 0 ;
27368 int res1 = 0 ;
27369 void *argp2 = 0 ;
27370 int res2 = 0 ;
27371 void *argp3 = 0 ;
27372 int res3 = 0 ;
27373 PyObject * obj0 = 0 ;
27374 PyObject * obj1 = 0 ;
27375 PyObject * obj2 = 0 ;
27376 char * kwnames[] = {
27377 (char *) "self",(char *) "win",(char *) "event", NULL
27378 };
27379
27380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27382 if (!SWIG_IsOK(res1)) {
27383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27384 }
27385 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27386 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27387 if (!SWIG_IsOK(res2)) {
27388 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27389 }
27390 arg2 = reinterpret_cast< wxWindow * >(argp2);
27391 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27392 if (!SWIG_IsOK(res3)) {
27393 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27394 }
27395 if (!argp3) {
27396 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27397 }
27398 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 {
27406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27407 }
27408 return resultobj;
27409 fail:
27410 return NULL;
27411 }
27412
27413
27414 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27415 PyObject *resultobj = 0;
27416 wxPyApp *arg1 = (wxPyApp *) 0 ;
27417 bool result;
27418 void *argp1 = 0 ;
27419 int res1 = 0 ;
27420 PyObject *swig_obj[1] ;
27421
27422 if (!args) SWIG_fail;
27423 swig_obj[0] = args;
27424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27425 if (!SWIG_IsOK(res1)) {
27426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27427 }
27428 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27429 {
27430 PyThreadState* __tstate = wxPyBeginAllowThreads();
27431 result = (bool)((wxPyApp const *)arg1)->IsActive();
27432 wxPyEndAllowThreads(__tstate);
27433 if (PyErr_Occurred()) SWIG_fail;
27434 }
27435 {
27436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27437 }
27438 return resultobj;
27439 fail:
27440 return NULL;
27441 }
27442
27443
27444 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27445 PyObject *resultobj = 0;
27446 wxPyApp *arg1 = (wxPyApp *) 0 ;
27447 wxWindow *arg2 = (wxWindow *) 0 ;
27448 void *argp1 = 0 ;
27449 int res1 = 0 ;
27450 void *argp2 = 0 ;
27451 int res2 = 0 ;
27452 PyObject * obj0 = 0 ;
27453 PyObject * obj1 = 0 ;
27454 char * kwnames[] = {
27455 (char *) "self",(char *) "win", NULL
27456 };
27457
27458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27460 if (!SWIG_IsOK(res1)) {
27461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27462 }
27463 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27465 if (!SWIG_IsOK(res2)) {
27466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27467 }
27468 arg2 = reinterpret_cast< wxWindow * >(argp2);
27469 {
27470 PyThreadState* __tstate = wxPyBeginAllowThreads();
27471 (arg1)->SetTopWindow(arg2);
27472 wxPyEndAllowThreads(__tstate);
27473 if (PyErr_Occurred()) SWIG_fail;
27474 }
27475 resultobj = SWIG_Py_Void();
27476 return resultobj;
27477 fail:
27478 return NULL;
27479 }
27480
27481
27482 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27483 PyObject *resultobj = 0;
27484 wxPyApp *arg1 = (wxPyApp *) 0 ;
27485 wxWindow *result = 0 ;
27486 void *argp1 = 0 ;
27487 int res1 = 0 ;
27488 PyObject *swig_obj[1] ;
27489
27490 if (!args) SWIG_fail;
27491 swig_obj[0] = args;
27492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27493 if (!SWIG_IsOK(res1)) {
27494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27495 }
27496 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27497 {
27498 PyThreadState* __tstate = wxPyBeginAllowThreads();
27499 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27500 wxPyEndAllowThreads(__tstate);
27501 if (PyErr_Occurred()) SWIG_fail;
27502 }
27503 {
27504 resultobj = wxPyMake_wxObject(result, (bool)0);
27505 }
27506 return resultobj;
27507 fail:
27508 return NULL;
27509 }
27510
27511
27512 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj = 0;
27514 wxPyApp *arg1 = (wxPyApp *) 0 ;
27515 bool arg2 ;
27516 void *argp1 = 0 ;
27517 int res1 = 0 ;
27518 bool val2 ;
27519 int ecode2 = 0 ;
27520 PyObject * obj0 = 0 ;
27521 PyObject * obj1 = 0 ;
27522 char * kwnames[] = {
27523 (char *) "self",(char *) "flag", NULL
27524 };
27525
27526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27528 if (!SWIG_IsOK(res1)) {
27529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27530 }
27531 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27532 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27533 if (!SWIG_IsOK(ecode2)) {
27534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27535 }
27536 arg2 = static_cast< bool >(val2);
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 (arg1)->SetExitOnFrameDelete(arg2);
27540 wxPyEndAllowThreads(__tstate);
27541 if (PyErr_Occurred()) SWIG_fail;
27542 }
27543 resultobj = SWIG_Py_Void();
27544 return resultobj;
27545 fail:
27546 return NULL;
27547 }
27548
27549
27550 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27551 PyObject *resultobj = 0;
27552 wxPyApp *arg1 = (wxPyApp *) 0 ;
27553 bool result;
27554 void *argp1 = 0 ;
27555 int res1 = 0 ;
27556 PyObject *swig_obj[1] ;
27557
27558 if (!args) SWIG_fail;
27559 swig_obj[0] = args;
27560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27561 if (!SWIG_IsOK(res1)) {
27562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27563 }
27564 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27565 {
27566 PyThreadState* __tstate = wxPyBeginAllowThreads();
27567 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27568 wxPyEndAllowThreads(__tstate);
27569 if (PyErr_Occurred()) SWIG_fail;
27570 }
27571 {
27572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27573 }
27574 return resultobj;
27575 fail:
27576 return NULL;
27577 }
27578
27579
27580 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27581 PyObject *resultobj = 0;
27582 wxPyApp *arg1 = (wxPyApp *) 0 ;
27583 bool arg2 ;
27584 void *argp1 = 0 ;
27585 int res1 = 0 ;
27586 bool val2 ;
27587 int ecode2 = 0 ;
27588 PyObject * obj0 = 0 ;
27589 PyObject * obj1 = 0 ;
27590 char * kwnames[] = {
27591 (char *) "self",(char *) "flag", NULL
27592 };
27593
27594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27596 if (!SWIG_IsOK(res1)) {
27597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27598 }
27599 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27600 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27601 if (!SWIG_IsOK(ecode2)) {
27602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27603 }
27604 arg2 = static_cast< bool >(val2);
27605 {
27606 PyThreadState* __tstate = wxPyBeginAllowThreads();
27607 (arg1)->SetUseBestVisual(arg2);
27608 wxPyEndAllowThreads(__tstate);
27609 if (PyErr_Occurred()) SWIG_fail;
27610 }
27611 resultobj = SWIG_Py_Void();
27612 return resultobj;
27613 fail:
27614 return NULL;
27615 }
27616
27617
27618 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27619 PyObject *resultobj = 0;
27620 wxPyApp *arg1 = (wxPyApp *) 0 ;
27621 bool result;
27622 void *argp1 = 0 ;
27623 int res1 = 0 ;
27624 PyObject *swig_obj[1] ;
27625
27626 if (!args) SWIG_fail;
27627 swig_obj[0] = args;
27628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27629 if (!SWIG_IsOK(res1)) {
27630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27631 }
27632 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27633 {
27634 PyThreadState* __tstate = wxPyBeginAllowThreads();
27635 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27636 wxPyEndAllowThreads(__tstate);
27637 if (PyErr_Occurred()) SWIG_fail;
27638 }
27639 {
27640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27641 }
27642 return resultobj;
27643 fail:
27644 return NULL;
27645 }
27646
27647
27648 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27649 PyObject *resultobj = 0;
27650 wxPyApp *arg1 = (wxPyApp *) 0 ;
27651 int arg2 ;
27652 void *argp1 = 0 ;
27653 int res1 = 0 ;
27654 int val2 ;
27655 int ecode2 = 0 ;
27656 PyObject * obj0 = 0 ;
27657 PyObject * obj1 = 0 ;
27658 char * kwnames[] = {
27659 (char *) "self",(char *) "mode", NULL
27660 };
27661
27662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27664 if (!SWIG_IsOK(res1)) {
27665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27666 }
27667 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27668 ecode2 = SWIG_AsVal_int(obj1, &val2);
27669 if (!SWIG_IsOK(ecode2)) {
27670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27671 }
27672 arg2 = static_cast< int >(val2);
27673 {
27674 PyThreadState* __tstate = wxPyBeginAllowThreads();
27675 (arg1)->SetPrintMode(arg2);
27676 wxPyEndAllowThreads(__tstate);
27677 if (PyErr_Occurred()) SWIG_fail;
27678 }
27679 resultobj = SWIG_Py_Void();
27680 return resultobj;
27681 fail:
27682 return NULL;
27683 }
27684
27685
27686 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27687 PyObject *resultobj = 0;
27688 wxPyApp *arg1 = (wxPyApp *) 0 ;
27689 int result;
27690 void *argp1 = 0 ;
27691 int res1 = 0 ;
27692 PyObject *swig_obj[1] ;
27693
27694 if (!args) SWIG_fail;
27695 swig_obj[0] = args;
27696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27697 if (!SWIG_IsOK(res1)) {
27698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27699 }
27700 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27701 {
27702 PyThreadState* __tstate = wxPyBeginAllowThreads();
27703 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27704 wxPyEndAllowThreads(__tstate);
27705 if (PyErr_Occurred()) SWIG_fail;
27706 }
27707 resultobj = SWIG_From_int(static_cast< int >(result));
27708 return resultobj;
27709 fail:
27710 return NULL;
27711 }
27712
27713
27714 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27715 PyObject *resultobj = 0;
27716 wxPyApp *arg1 = (wxPyApp *) 0 ;
27717 int arg2 ;
27718 void *argp1 = 0 ;
27719 int res1 = 0 ;
27720 int val2 ;
27721 int ecode2 = 0 ;
27722 PyObject * obj0 = 0 ;
27723 PyObject * obj1 = 0 ;
27724 char * kwnames[] = {
27725 (char *) "self",(char *) "mode", NULL
27726 };
27727
27728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27730 if (!SWIG_IsOK(res1)) {
27731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27732 }
27733 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27734 ecode2 = SWIG_AsVal_int(obj1, &val2);
27735 if (!SWIG_IsOK(ecode2)) {
27736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27737 }
27738 arg2 = static_cast< int >(val2);
27739 {
27740 PyThreadState* __tstate = wxPyBeginAllowThreads();
27741 (arg1)->SetAssertMode(arg2);
27742 wxPyEndAllowThreads(__tstate);
27743 if (PyErr_Occurred()) SWIG_fail;
27744 }
27745 resultobj = SWIG_Py_Void();
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27753 PyObject *resultobj = 0;
27754 wxPyApp *arg1 = (wxPyApp *) 0 ;
27755 int result;
27756 void *argp1 = 0 ;
27757 int res1 = 0 ;
27758 PyObject *swig_obj[1] ;
27759
27760 if (!args) SWIG_fail;
27761 swig_obj[0] = args;
27762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27763 if (!SWIG_IsOK(res1)) {
27764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27765 }
27766 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27767 {
27768 PyThreadState* __tstate = wxPyBeginAllowThreads();
27769 result = (int)(arg1)->GetAssertMode();
27770 wxPyEndAllowThreads(__tstate);
27771 if (PyErr_Occurred()) SWIG_fail;
27772 }
27773 resultobj = SWIG_From_int(static_cast< int >(result));
27774 return resultobj;
27775 fail:
27776 return NULL;
27777 }
27778
27779
27780 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27781 PyObject *resultobj = 0;
27782 bool result;
27783
27784 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27785 {
27786 PyThreadState* __tstate = wxPyBeginAllowThreads();
27787 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 {
27792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27793 }
27794 return resultobj;
27795 fail:
27796 return NULL;
27797 }
27798
27799
27800 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27801 PyObject *resultobj = 0;
27802 long result;
27803
27804 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27805 {
27806 PyThreadState* __tstate = wxPyBeginAllowThreads();
27807 result = (long)wxPyApp::GetMacAboutMenuItemId();
27808 wxPyEndAllowThreads(__tstate);
27809 if (PyErr_Occurred()) SWIG_fail;
27810 }
27811 resultobj = SWIG_From_long(static_cast< long >(result));
27812 return resultobj;
27813 fail:
27814 return NULL;
27815 }
27816
27817
27818 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27819 PyObject *resultobj = 0;
27820 long result;
27821
27822 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27823 {
27824 PyThreadState* __tstate = wxPyBeginAllowThreads();
27825 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27826 wxPyEndAllowThreads(__tstate);
27827 if (PyErr_Occurred()) SWIG_fail;
27828 }
27829 resultobj = SWIG_From_long(static_cast< long >(result));
27830 return resultobj;
27831 fail:
27832 return NULL;
27833 }
27834
27835
27836 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27837 PyObject *resultobj = 0;
27838 long result;
27839
27840 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27841 {
27842 PyThreadState* __tstate = wxPyBeginAllowThreads();
27843 result = (long)wxPyApp::GetMacExitMenuItemId();
27844 wxPyEndAllowThreads(__tstate);
27845 if (PyErr_Occurred()) SWIG_fail;
27846 }
27847 resultobj = SWIG_From_long(static_cast< long >(result));
27848 return resultobj;
27849 fail:
27850 return NULL;
27851 }
27852
27853
27854 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27855 PyObject *resultobj = 0;
27856 wxString result;
27857
27858 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27859 {
27860 PyThreadState* __tstate = wxPyBeginAllowThreads();
27861 result = wxPyApp::GetMacHelpMenuTitleName();
27862 wxPyEndAllowThreads(__tstate);
27863 if (PyErr_Occurred()) SWIG_fail;
27864 }
27865 {
27866 #if wxUSE_UNICODE
27867 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27868 #else
27869 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27870 #endif
27871 }
27872 return resultobj;
27873 fail:
27874 return NULL;
27875 }
27876
27877
27878 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27879 PyObject *resultobj = 0;
27880 bool arg1 ;
27881 bool val1 ;
27882 int ecode1 = 0 ;
27883 PyObject * obj0 = 0 ;
27884 char * kwnames[] = {
27885 (char *) "val", NULL
27886 };
27887
27888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27889 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27890 if (!SWIG_IsOK(ecode1)) {
27891 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27892 }
27893 arg1 = static_cast< bool >(val1);
27894 {
27895 PyThreadState* __tstate = wxPyBeginAllowThreads();
27896 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27897 wxPyEndAllowThreads(__tstate);
27898 if (PyErr_Occurred()) SWIG_fail;
27899 }
27900 resultobj = SWIG_Py_Void();
27901 return resultobj;
27902 fail:
27903 return NULL;
27904 }
27905
27906
27907 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27908 PyObject *resultobj = 0;
27909 long arg1 ;
27910 long val1 ;
27911 int ecode1 = 0 ;
27912 PyObject * obj0 = 0 ;
27913 char * kwnames[] = {
27914 (char *) "val", NULL
27915 };
27916
27917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27918 ecode1 = SWIG_AsVal_long(obj0, &val1);
27919 if (!SWIG_IsOK(ecode1)) {
27920 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
27921 }
27922 arg1 = static_cast< long >(val1);
27923 {
27924 PyThreadState* __tstate = wxPyBeginAllowThreads();
27925 wxPyApp::SetMacAboutMenuItemId(arg1);
27926 wxPyEndAllowThreads(__tstate);
27927 if (PyErr_Occurred()) SWIG_fail;
27928 }
27929 resultobj = SWIG_Py_Void();
27930 return resultobj;
27931 fail:
27932 return NULL;
27933 }
27934
27935
27936 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27937 PyObject *resultobj = 0;
27938 long arg1 ;
27939 long val1 ;
27940 int ecode1 = 0 ;
27941 PyObject * obj0 = 0 ;
27942 char * kwnames[] = {
27943 (char *) "val", NULL
27944 };
27945
27946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
27947 ecode1 = SWIG_AsVal_long(obj0, &val1);
27948 if (!SWIG_IsOK(ecode1)) {
27949 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
27950 }
27951 arg1 = static_cast< long >(val1);
27952 {
27953 PyThreadState* __tstate = wxPyBeginAllowThreads();
27954 wxPyApp::SetMacPreferencesMenuItemId(arg1);
27955 wxPyEndAllowThreads(__tstate);
27956 if (PyErr_Occurred()) SWIG_fail;
27957 }
27958 resultobj = SWIG_Py_Void();
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj = 0;
27967 long arg1 ;
27968 long val1 ;
27969 int ecode1 = 0 ;
27970 PyObject * obj0 = 0 ;
27971 char * kwnames[] = {
27972 (char *) "val", NULL
27973 };
27974
27975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
27976 ecode1 = SWIG_AsVal_long(obj0, &val1);
27977 if (!SWIG_IsOK(ecode1)) {
27978 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
27979 }
27980 arg1 = static_cast< long >(val1);
27981 {
27982 PyThreadState* __tstate = wxPyBeginAllowThreads();
27983 wxPyApp::SetMacExitMenuItemId(arg1);
27984 wxPyEndAllowThreads(__tstate);
27985 if (PyErr_Occurred()) SWIG_fail;
27986 }
27987 resultobj = SWIG_Py_Void();
27988 return resultobj;
27989 fail:
27990 return NULL;
27991 }
27992
27993
27994 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27995 PyObject *resultobj = 0;
27996 wxString *arg1 = 0 ;
27997 bool temp1 = false ;
27998 PyObject * obj0 = 0 ;
27999 char * kwnames[] = {
28000 (char *) "val", NULL
28001 };
28002
28003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28004 {
28005 arg1 = wxString_in_helper(obj0);
28006 if (arg1 == NULL) SWIG_fail;
28007 temp1 = true;
28008 }
28009 {
28010 PyThreadState* __tstate = wxPyBeginAllowThreads();
28011 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28012 wxPyEndAllowThreads(__tstate);
28013 if (PyErr_Occurred()) SWIG_fail;
28014 }
28015 resultobj = SWIG_Py_Void();
28016 {
28017 if (temp1)
28018 delete arg1;
28019 }
28020 return resultobj;
28021 fail:
28022 {
28023 if (temp1)
28024 delete arg1;
28025 }
28026 return NULL;
28027 }
28028
28029
28030 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28031 PyObject *resultobj = 0;
28032 wxPyApp *arg1 = (wxPyApp *) 0 ;
28033 void *argp1 = 0 ;
28034 int res1 = 0 ;
28035 PyObject *swig_obj[1] ;
28036
28037 if (!args) SWIG_fail;
28038 swig_obj[0] = args;
28039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28040 if (!SWIG_IsOK(res1)) {
28041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28042 }
28043 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28044 {
28045 PyThreadState* __tstate = wxPyBeginAllowThreads();
28046 (arg1)->_BootstrapApp();
28047 wxPyEndAllowThreads(__tstate);
28048 if (PyErr_Occurred()) SWIG_fail;
28049 }
28050 resultobj = SWIG_Py_Void();
28051 return resultobj;
28052 fail:
28053 return NULL;
28054 }
28055
28056
28057 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28058 PyObject *resultobj = 0;
28059 int result;
28060
28061 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28062 {
28063 PyThreadState* __tstate = wxPyBeginAllowThreads();
28064 result = (int)wxPyApp::GetComCtl32Version();
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 resultobj = SWIG_From_int(static_cast< int >(result));
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28076 PyObject *obj;
28077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28078 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28079 return SWIG_Py_Void();
28080 }
28081
28082 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28083 return SWIG_Python_InitShadowInstance(args);
28084 }
28085
28086 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28087 PyObject *resultobj = 0;
28088
28089 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 wxExit();
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 resultobj = SWIG_Py_Void();
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28104 PyObject *resultobj = 0;
28105 bool result;
28106
28107 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28108 {
28109 PyThreadState* __tstate = wxPyBeginAllowThreads();
28110 result = (bool)wxYield();
28111 wxPyEndAllowThreads(__tstate);
28112 if (PyErr_Occurred()) SWIG_fail;
28113 }
28114 {
28115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28116 }
28117 return resultobj;
28118 fail:
28119 return NULL;
28120 }
28121
28122
28123 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28124 PyObject *resultobj = 0;
28125 bool result;
28126
28127 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28128 {
28129 PyThreadState* __tstate = wxPyBeginAllowThreads();
28130 result = (bool)wxYieldIfNeeded();
28131 wxPyEndAllowThreads(__tstate);
28132 if (PyErr_Occurred()) SWIG_fail;
28133 }
28134 {
28135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28136 }
28137 return resultobj;
28138 fail:
28139 return NULL;
28140 }
28141
28142
28143 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28144 PyObject *resultobj = 0;
28145 wxWindow *arg1 = (wxWindow *) NULL ;
28146 bool arg2 = (bool) false ;
28147 bool result;
28148 void *argp1 = 0 ;
28149 int res1 = 0 ;
28150 bool val2 ;
28151 int ecode2 = 0 ;
28152 PyObject * obj0 = 0 ;
28153 PyObject * obj1 = 0 ;
28154 char * kwnames[] = {
28155 (char *) "win",(char *) "onlyIfNeeded", NULL
28156 };
28157
28158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28159 if (obj0) {
28160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28161 if (!SWIG_IsOK(res1)) {
28162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28163 }
28164 arg1 = reinterpret_cast< wxWindow * >(argp1);
28165 }
28166 if (obj1) {
28167 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28168 if (!SWIG_IsOK(ecode2)) {
28169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28170 }
28171 arg2 = static_cast< bool >(val2);
28172 }
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 result = (bool)wxSafeYield(arg1,arg2);
28176 wxPyEndAllowThreads(__tstate);
28177 if (PyErr_Occurred()) SWIG_fail;
28178 }
28179 {
28180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28181 }
28182 return resultobj;
28183 fail:
28184 return NULL;
28185 }
28186
28187
28188 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28189 PyObject *resultobj = 0;
28190
28191 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28192 {
28193 PyThreadState* __tstate = wxPyBeginAllowThreads();
28194 wxWakeUpIdle();
28195 wxPyEndAllowThreads(__tstate);
28196 if (PyErr_Occurred()) SWIG_fail;
28197 }
28198 resultobj = SWIG_Py_Void();
28199 return resultobj;
28200 fail:
28201 return NULL;
28202 }
28203
28204
28205 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28206 PyObject *resultobj = 0;
28207 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28208 wxEvent *arg2 = 0 ;
28209 void *argp1 = 0 ;
28210 int res1 = 0 ;
28211 void *argp2 = 0 ;
28212 int res2 = 0 ;
28213 PyObject * obj0 = 0 ;
28214 PyObject * obj1 = 0 ;
28215 char * kwnames[] = {
28216 (char *) "dest",(char *) "event", NULL
28217 };
28218
28219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28221 if (!SWIG_IsOK(res1)) {
28222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28223 }
28224 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28225 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28226 if (!SWIG_IsOK(res2)) {
28227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28228 }
28229 if (!argp2) {
28230 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28231 }
28232 arg2 = reinterpret_cast< wxEvent * >(argp2);
28233 {
28234 PyThreadState* __tstate = wxPyBeginAllowThreads();
28235 wxPostEvent(arg1,*arg2);
28236 wxPyEndAllowThreads(__tstate);
28237 if (PyErr_Occurred()) SWIG_fail;
28238 }
28239 resultobj = SWIG_Py_Void();
28240 return resultobj;
28241 fail:
28242 return NULL;
28243 }
28244
28245
28246 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28247 PyObject *resultobj = 0;
28248
28249 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28250 {
28251 PyThreadState* __tstate = wxPyBeginAllowThreads();
28252 wxApp_CleanUp();
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 resultobj = SWIG_Py_Void();
28257 return resultobj;
28258 fail:
28259 return NULL;
28260 }
28261
28262
28263 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28264 PyObject *resultobj = 0;
28265 wxPyApp *result = 0 ;
28266
28267 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28268 {
28269 PyThreadState* __tstate = wxPyBeginAllowThreads();
28270 result = (wxPyApp *)wxPyGetApp();
28271 wxPyEndAllowThreads(__tstate);
28272 if (PyErr_Occurred()) SWIG_fail;
28273 }
28274 {
28275 resultobj = wxPyMake_wxObject(result, 0);
28276 }
28277 return resultobj;
28278 fail:
28279 return NULL;
28280 }
28281
28282
28283 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28284 PyObject *resultobj = 0;
28285 char *arg1 = (char *) 0 ;
28286 int res1 ;
28287 char *buf1 = 0 ;
28288 int alloc1 = 0 ;
28289 PyObject * obj0 = 0 ;
28290 char * kwnames[] = {
28291 (char *) "encoding", NULL
28292 };
28293
28294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28295 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28296 if (!SWIG_IsOK(res1)) {
28297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28298 }
28299 arg1 = buf1;
28300 {
28301 PyThreadState* __tstate = wxPyBeginAllowThreads();
28302 wxSetDefaultPyEncoding((char const *)arg1);
28303 wxPyEndAllowThreads(__tstate);
28304 if (PyErr_Occurred()) SWIG_fail;
28305 }
28306 resultobj = SWIG_Py_Void();
28307 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28308 return resultobj;
28309 fail:
28310 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28311 return NULL;
28312 }
28313
28314
28315 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28316 PyObject *resultobj = 0;
28317 char *result = 0 ;
28318
28319 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28320 {
28321 PyThreadState* __tstate = wxPyBeginAllowThreads();
28322 result = (char *)wxGetDefaultPyEncoding();
28323 wxPyEndAllowThreads(__tstate);
28324 if (PyErr_Occurred()) SWIG_fail;
28325 }
28326 resultobj = SWIG_FromCharPtr(result);
28327 return resultobj;
28328 fail:
28329 return NULL;
28330 }
28331
28332
28333 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28334 PyObject *resultobj = 0;
28335 wxEventLoop *result = 0 ;
28336
28337 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28338 {
28339 PyThreadState* __tstate = wxPyBeginAllowThreads();
28340 result = (wxEventLoop *)new wxEventLoop();
28341 wxPyEndAllowThreads(__tstate);
28342 if (PyErr_Occurred()) SWIG_fail;
28343 }
28344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28345 return resultobj;
28346 fail:
28347 return NULL;
28348 }
28349
28350
28351 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28352 PyObject *resultobj = 0;
28353 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28354 void *argp1 = 0 ;
28355 int res1 = 0 ;
28356 PyObject *swig_obj[1] ;
28357
28358 if (!args) SWIG_fail;
28359 swig_obj[0] = args;
28360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28361 if (!SWIG_IsOK(res1)) {
28362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28363 }
28364 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28365 {
28366 PyThreadState* __tstate = wxPyBeginAllowThreads();
28367 delete arg1;
28368
28369 wxPyEndAllowThreads(__tstate);
28370 if (PyErr_Occurred()) SWIG_fail;
28371 }
28372 resultobj = SWIG_Py_Void();
28373 return resultobj;
28374 fail:
28375 return NULL;
28376 }
28377
28378
28379 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28380 PyObject *resultobj = 0;
28381 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28382 int result;
28383 void *argp1 = 0 ;
28384 int res1 = 0 ;
28385 PyObject *swig_obj[1] ;
28386
28387 if (!args) SWIG_fail;
28388 swig_obj[0] = args;
28389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28390 if (!SWIG_IsOK(res1)) {
28391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28392 }
28393 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 result = (int)(arg1)->Run();
28397 wxPyEndAllowThreads(__tstate);
28398 if (PyErr_Occurred()) SWIG_fail;
28399 }
28400 resultobj = SWIG_From_int(static_cast< int >(result));
28401 return resultobj;
28402 fail:
28403 return NULL;
28404 }
28405
28406
28407 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28408 PyObject *resultobj = 0;
28409 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28410 int arg2 = (int) 0 ;
28411 void *argp1 = 0 ;
28412 int res1 = 0 ;
28413 int val2 ;
28414 int ecode2 = 0 ;
28415 PyObject * obj0 = 0 ;
28416 PyObject * obj1 = 0 ;
28417 char * kwnames[] = {
28418 (char *) "self",(char *) "rc", NULL
28419 };
28420
28421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28423 if (!SWIG_IsOK(res1)) {
28424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28425 }
28426 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28427 if (obj1) {
28428 ecode2 = SWIG_AsVal_int(obj1, &val2);
28429 if (!SWIG_IsOK(ecode2)) {
28430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28431 }
28432 arg2 = static_cast< int >(val2);
28433 }
28434 {
28435 PyThreadState* __tstate = wxPyBeginAllowThreads();
28436 (arg1)->Exit(arg2);
28437 wxPyEndAllowThreads(__tstate);
28438 if (PyErr_Occurred()) SWIG_fail;
28439 }
28440 resultobj = SWIG_Py_Void();
28441 return resultobj;
28442 fail:
28443 return NULL;
28444 }
28445
28446
28447 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28448 PyObject *resultobj = 0;
28449 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28450 bool result;
28451 void *argp1 = 0 ;
28452 int res1 = 0 ;
28453 PyObject *swig_obj[1] ;
28454
28455 if (!args) SWIG_fail;
28456 swig_obj[0] = args;
28457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28458 if (!SWIG_IsOK(res1)) {
28459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28460 }
28461 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28462 {
28463 PyThreadState* __tstate = wxPyBeginAllowThreads();
28464 result = (bool)((wxEventLoop const *)arg1)->Pending();
28465 wxPyEndAllowThreads(__tstate);
28466 if (PyErr_Occurred()) SWIG_fail;
28467 }
28468 {
28469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28470 }
28471 return resultobj;
28472 fail:
28473 return NULL;
28474 }
28475
28476
28477 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28478 PyObject *resultobj = 0;
28479 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28480 bool result;
28481 void *argp1 = 0 ;
28482 int res1 = 0 ;
28483 PyObject *swig_obj[1] ;
28484
28485 if (!args) SWIG_fail;
28486 swig_obj[0] = args;
28487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28488 if (!SWIG_IsOK(res1)) {
28489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28490 }
28491 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28492 {
28493 PyThreadState* __tstate = wxPyBeginAllowThreads();
28494 result = (bool)(arg1)->Dispatch();
28495 wxPyEndAllowThreads(__tstate);
28496 if (PyErr_Occurred()) SWIG_fail;
28497 }
28498 {
28499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28500 }
28501 return resultobj;
28502 fail:
28503 return NULL;
28504 }
28505
28506
28507 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28508 PyObject *resultobj = 0;
28509 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28510 bool result;
28511 void *argp1 = 0 ;
28512 int res1 = 0 ;
28513 PyObject *swig_obj[1] ;
28514
28515 if (!args) SWIG_fail;
28516 swig_obj[0] = args;
28517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28518 if (!SWIG_IsOK(res1)) {
28519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28520 }
28521 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 {
28529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28530 }
28531 return resultobj;
28532 fail:
28533 return NULL;
28534 }
28535
28536
28537 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28538 PyObject *resultobj = 0;
28539 wxEventLoop *result = 0 ;
28540
28541 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28542 {
28543 PyThreadState* __tstate = wxPyBeginAllowThreads();
28544 result = (wxEventLoop *)wxEventLoop::GetActive();
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28549 return resultobj;
28550 fail:
28551 return NULL;
28552 }
28553
28554
28555 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28556 PyObject *resultobj = 0;
28557 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28558 void *argp1 = 0 ;
28559 int res1 = 0 ;
28560 PyObject * obj0 = 0 ;
28561 char * kwnames[] = {
28562 (char *) "loop", NULL
28563 };
28564
28565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28567 if (!SWIG_IsOK(res1)) {
28568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28569 }
28570 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28571 {
28572 PyThreadState* __tstate = wxPyBeginAllowThreads();
28573 wxEventLoop::SetActive(arg1);
28574 wxPyEndAllowThreads(__tstate);
28575 if (PyErr_Occurred()) SWIG_fail;
28576 }
28577 resultobj = SWIG_Py_Void();
28578 return resultobj;
28579 fail:
28580 return NULL;
28581 }
28582
28583
28584 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28585 PyObject *obj;
28586 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28587 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28588 return SWIG_Py_Void();
28589 }
28590
28591 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28592 return SWIG_Python_InitShadowInstance(args);
28593 }
28594
28595 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28596 PyObject *resultobj = 0;
28597 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28598 wxEventLoopActivator *result = 0 ;
28599 void *argp1 = 0 ;
28600 int res1 = 0 ;
28601 PyObject * obj0 = 0 ;
28602 char * kwnames[] = {
28603 (char *) "evtLoop", NULL
28604 };
28605
28606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28608 if (!SWIG_IsOK(res1)) {
28609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28610 }
28611 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28612 {
28613 PyThreadState* __tstate = wxPyBeginAllowThreads();
28614 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28615 wxPyEndAllowThreads(__tstate);
28616 if (PyErr_Occurred()) SWIG_fail;
28617 }
28618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28619 return resultobj;
28620 fail:
28621 return NULL;
28622 }
28623
28624
28625 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28626 PyObject *resultobj = 0;
28627 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28628 void *argp1 = 0 ;
28629 int res1 = 0 ;
28630 PyObject *swig_obj[1] ;
28631
28632 if (!args) SWIG_fail;
28633 swig_obj[0] = args;
28634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28635 if (!SWIG_IsOK(res1)) {
28636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28637 }
28638 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28639 {
28640 PyThreadState* __tstate = wxPyBeginAllowThreads();
28641 delete arg1;
28642
28643 wxPyEndAllowThreads(__tstate);
28644 if (PyErr_Occurred()) SWIG_fail;
28645 }
28646 resultobj = SWIG_Py_Void();
28647 return resultobj;
28648 fail:
28649 return NULL;
28650 }
28651
28652
28653 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28654 PyObject *obj;
28655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28656 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28657 return SWIG_Py_Void();
28658 }
28659
28660 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28661 return SWIG_Python_InitShadowInstance(args);
28662 }
28663
28664 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28665 PyObject *resultobj = 0;
28666 int arg1 = (int) 0 ;
28667 int arg2 = (int) 0 ;
28668 int arg3 = (int) 0 ;
28669 wxAcceleratorEntry *result = 0 ;
28670 int val1 ;
28671 int ecode1 = 0 ;
28672 int val2 ;
28673 int ecode2 = 0 ;
28674 int val3 ;
28675 int ecode3 = 0 ;
28676 PyObject * obj0 = 0 ;
28677 PyObject * obj1 = 0 ;
28678 PyObject * obj2 = 0 ;
28679 char * kwnames[] = {
28680 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28681 };
28682
28683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28684 if (obj0) {
28685 ecode1 = SWIG_AsVal_int(obj0, &val1);
28686 if (!SWIG_IsOK(ecode1)) {
28687 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28688 }
28689 arg1 = static_cast< int >(val1);
28690 }
28691 if (obj1) {
28692 ecode2 = SWIG_AsVal_int(obj1, &val2);
28693 if (!SWIG_IsOK(ecode2)) {
28694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28695 }
28696 arg2 = static_cast< int >(val2);
28697 }
28698 if (obj2) {
28699 ecode3 = SWIG_AsVal_int(obj2, &val3);
28700 if (!SWIG_IsOK(ecode3)) {
28701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28702 }
28703 arg3 = static_cast< int >(val3);
28704 }
28705 {
28706 PyThreadState* __tstate = wxPyBeginAllowThreads();
28707 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28708 wxPyEndAllowThreads(__tstate);
28709 if (PyErr_Occurred()) SWIG_fail;
28710 }
28711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28712 return resultobj;
28713 fail:
28714 return NULL;
28715 }
28716
28717
28718 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28719 PyObject *resultobj = 0;
28720 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28721 void *argp1 = 0 ;
28722 int res1 = 0 ;
28723 PyObject *swig_obj[1] ;
28724
28725 if (!args) SWIG_fail;
28726 swig_obj[0] = args;
28727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28728 if (!SWIG_IsOK(res1)) {
28729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28730 }
28731 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28732 {
28733 PyThreadState* __tstate = wxPyBeginAllowThreads();
28734 delete arg1;
28735
28736 wxPyEndAllowThreads(__tstate);
28737 if (PyErr_Occurred()) SWIG_fail;
28738 }
28739 resultobj = SWIG_Py_Void();
28740 return resultobj;
28741 fail:
28742 return NULL;
28743 }
28744
28745
28746 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28747 PyObject *resultobj = 0;
28748 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28749 int arg2 ;
28750 int arg3 ;
28751 int arg4 ;
28752 void *argp1 = 0 ;
28753 int res1 = 0 ;
28754 int val2 ;
28755 int ecode2 = 0 ;
28756 int val3 ;
28757 int ecode3 = 0 ;
28758 int val4 ;
28759 int ecode4 = 0 ;
28760 PyObject * obj0 = 0 ;
28761 PyObject * obj1 = 0 ;
28762 PyObject * obj2 = 0 ;
28763 PyObject * obj3 = 0 ;
28764 char * kwnames[] = {
28765 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28766 };
28767
28768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28770 if (!SWIG_IsOK(res1)) {
28771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28772 }
28773 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28774 ecode2 = SWIG_AsVal_int(obj1, &val2);
28775 if (!SWIG_IsOK(ecode2)) {
28776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28777 }
28778 arg2 = static_cast< int >(val2);
28779 ecode3 = SWIG_AsVal_int(obj2, &val3);
28780 if (!SWIG_IsOK(ecode3)) {
28781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28782 }
28783 arg3 = static_cast< int >(val3);
28784 ecode4 = SWIG_AsVal_int(obj3, &val4);
28785 if (!SWIG_IsOK(ecode4)) {
28786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28787 }
28788 arg4 = static_cast< int >(val4);
28789 {
28790 PyThreadState* __tstate = wxPyBeginAllowThreads();
28791 (arg1)->Set(arg2,arg3,arg4);
28792 wxPyEndAllowThreads(__tstate);
28793 if (PyErr_Occurred()) SWIG_fail;
28794 }
28795 resultobj = SWIG_Py_Void();
28796 return resultobj;
28797 fail:
28798 return NULL;
28799 }
28800
28801
28802 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28803 PyObject *resultobj = 0;
28804 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28805 int result;
28806 void *argp1 = 0 ;
28807 int res1 = 0 ;
28808 PyObject *swig_obj[1] ;
28809
28810 if (!args) SWIG_fail;
28811 swig_obj[0] = args;
28812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28813 if (!SWIG_IsOK(res1)) {
28814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28815 }
28816 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28817 {
28818 PyThreadState* __tstate = wxPyBeginAllowThreads();
28819 result = (int)(arg1)->GetFlags();
28820 wxPyEndAllowThreads(__tstate);
28821 if (PyErr_Occurred()) SWIG_fail;
28822 }
28823 resultobj = SWIG_From_int(static_cast< int >(result));
28824 return resultobj;
28825 fail:
28826 return NULL;
28827 }
28828
28829
28830 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28831 PyObject *resultobj = 0;
28832 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28833 int result;
28834 void *argp1 = 0 ;
28835 int res1 = 0 ;
28836 PyObject *swig_obj[1] ;
28837
28838 if (!args) SWIG_fail;
28839 swig_obj[0] = args;
28840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28841 if (!SWIG_IsOK(res1)) {
28842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28843 }
28844 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28845 {
28846 PyThreadState* __tstate = wxPyBeginAllowThreads();
28847 result = (int)(arg1)->GetKeyCode();
28848 wxPyEndAllowThreads(__tstate);
28849 if (PyErr_Occurred()) SWIG_fail;
28850 }
28851 resultobj = SWIG_From_int(static_cast< int >(result));
28852 return resultobj;
28853 fail:
28854 return NULL;
28855 }
28856
28857
28858 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28859 PyObject *resultobj = 0;
28860 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28861 int result;
28862 void *argp1 = 0 ;
28863 int res1 = 0 ;
28864 PyObject *swig_obj[1] ;
28865
28866 if (!args) SWIG_fail;
28867 swig_obj[0] = args;
28868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28869 if (!SWIG_IsOK(res1)) {
28870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28871 }
28872 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 result = (int)(arg1)->GetCommand();
28876 wxPyEndAllowThreads(__tstate);
28877 if (PyErr_Occurred()) SWIG_fail;
28878 }
28879 resultobj = SWIG_From_int(static_cast< int >(result));
28880 return resultobj;
28881 fail:
28882 return NULL;
28883 }
28884
28885
28886 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28887 PyObject *obj;
28888 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28889 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28890 return SWIG_Py_Void();
28891 }
28892
28893 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28894 return SWIG_Python_InitShadowInstance(args);
28895 }
28896
28897 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28898 PyObject *resultobj = 0;
28899 int arg1 ;
28900 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28901 wxAcceleratorTable *result = 0 ;
28902 PyObject * obj0 = 0 ;
28903 char * kwnames[] = {
28904 (char *) "n", NULL
28905 };
28906
28907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28908 {
28909 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28910 if (arg2) arg1 = PyList_Size(obj0);
28911 else arg1 = 0;
28912 }
28913 {
28914 PyThreadState* __tstate = wxPyBeginAllowThreads();
28915 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28916 wxPyEndAllowThreads(__tstate);
28917 if (PyErr_Occurred()) SWIG_fail;
28918 }
28919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
28920 return resultobj;
28921 fail:
28922 return NULL;
28923 }
28924
28925
28926 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28927 PyObject *resultobj = 0;
28928 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28929 void *argp1 = 0 ;
28930 int res1 = 0 ;
28931 PyObject *swig_obj[1] ;
28932
28933 if (!args) SWIG_fail;
28934 swig_obj[0] = args;
28935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
28936 if (!SWIG_IsOK(res1)) {
28937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
28938 }
28939 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28940 {
28941 PyThreadState* __tstate = wxPyBeginAllowThreads();
28942 delete arg1;
28943
28944 wxPyEndAllowThreads(__tstate);
28945 if (PyErr_Occurred()) SWIG_fail;
28946 }
28947 resultobj = SWIG_Py_Void();
28948 return resultobj;
28949 fail:
28950 return NULL;
28951 }
28952
28953
28954 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28955 PyObject *resultobj = 0;
28956 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28957 bool result;
28958 void *argp1 = 0 ;
28959 int res1 = 0 ;
28960 PyObject *swig_obj[1] ;
28961
28962 if (!args) SWIG_fail;
28963 swig_obj[0] = args;
28964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
28965 if (!SWIG_IsOK(res1)) {
28966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
28967 }
28968 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28969 {
28970 PyThreadState* __tstate = wxPyBeginAllowThreads();
28971 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
28972 wxPyEndAllowThreads(__tstate);
28973 if (PyErr_Occurred()) SWIG_fail;
28974 }
28975 {
28976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28977 }
28978 return resultobj;
28979 fail:
28980 return NULL;
28981 }
28982
28983
28984 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28985 PyObject *obj;
28986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28987 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
28988 return SWIG_Py_Void();
28989 }
28990
28991 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28992 return SWIG_Python_InitShadowInstance(args);
28993 }
28994
28995 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
28996 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
28997 return 1;
28998 }
28999
29000
29001 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29002 PyObject *pyobj = 0;
29003
29004 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29005 return pyobj;
29006 }
29007
29008
29009 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29010 PyObject *resultobj = 0;
29011 wxString *arg1 = 0 ;
29012 wxAcceleratorEntry *result = 0 ;
29013 bool temp1 = false ;
29014 PyObject * obj0 = 0 ;
29015 char * kwnames[] = {
29016 (char *) "label", NULL
29017 };
29018
29019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29020 {
29021 arg1 = wxString_in_helper(obj0);
29022 if (arg1 == NULL) SWIG_fail;
29023 temp1 = true;
29024 }
29025 {
29026 PyThreadState* __tstate = wxPyBeginAllowThreads();
29027 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29028 wxPyEndAllowThreads(__tstate);
29029 if (PyErr_Occurred()) SWIG_fail;
29030 }
29031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29032 {
29033 if (temp1)
29034 delete arg1;
29035 }
29036 return resultobj;
29037 fail:
29038 {
29039 if (temp1)
29040 delete arg1;
29041 }
29042 return NULL;
29043 }
29044
29045
29046 SWIGINTERN int PanelNameStr_set(PyObject *) {
29047 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29048 return 1;
29049 }
29050
29051
29052 SWIGINTERN PyObject *PanelNameStr_get(void) {
29053 PyObject *pyobj = 0;
29054
29055 {
29056 #if wxUSE_UNICODE
29057 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29058 #else
29059 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29060 #endif
29061 }
29062 return pyobj;
29063 }
29064
29065
29066 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29067 PyObject *resultobj = 0;
29068 wxVisualAttributes *result = 0 ;
29069
29070 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29071 {
29072 PyThreadState* __tstate = wxPyBeginAllowThreads();
29073 result = (wxVisualAttributes *)new_wxVisualAttributes();
29074 wxPyEndAllowThreads(__tstate);
29075 if (PyErr_Occurred()) SWIG_fail;
29076 }
29077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29078 return resultobj;
29079 fail:
29080 return NULL;
29081 }
29082
29083
29084 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29085 PyObject *resultobj = 0;
29086 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29087 void *argp1 = 0 ;
29088 int res1 = 0 ;
29089 PyObject *swig_obj[1] ;
29090
29091 if (!args) SWIG_fail;
29092 swig_obj[0] = args;
29093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29094 if (!SWIG_IsOK(res1)) {
29095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29096 }
29097 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 delete_wxVisualAttributes(arg1);
29101
29102 wxPyEndAllowThreads(__tstate);
29103 if (PyErr_Occurred()) SWIG_fail;
29104 }
29105 resultobj = SWIG_Py_Void();
29106 return resultobj;
29107 fail:
29108 return NULL;
29109 }
29110
29111
29112 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29113 PyObject *resultobj = 0;
29114 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29115 wxFont *arg2 = (wxFont *) 0 ;
29116 void *argp1 = 0 ;
29117 int res1 = 0 ;
29118 void *argp2 = 0 ;
29119 int res2 = 0 ;
29120 PyObject *swig_obj[2] ;
29121
29122 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29124 if (!SWIG_IsOK(res1)) {
29125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29126 }
29127 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29128 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29129 if (!SWIG_IsOK(res2)) {
29130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29131 }
29132 arg2 = reinterpret_cast< wxFont * >(argp2);
29133 if (arg1) (arg1)->font = *arg2;
29134
29135 resultobj = SWIG_Py_Void();
29136 return resultobj;
29137 fail:
29138 return NULL;
29139 }
29140
29141
29142 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29143 PyObject *resultobj = 0;
29144 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29145 wxFont *result = 0 ;
29146 void *argp1 = 0 ;
29147 int res1 = 0 ;
29148 PyObject *swig_obj[1] ;
29149
29150 if (!args) SWIG_fail;
29151 swig_obj[0] = args;
29152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29153 if (!SWIG_IsOK(res1)) {
29154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29155 }
29156 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29157 result = (wxFont *)& ((arg1)->font);
29158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29159 return resultobj;
29160 fail:
29161 return NULL;
29162 }
29163
29164
29165 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29166 PyObject *resultobj = 0;
29167 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29168 wxColour *arg2 = (wxColour *) 0 ;
29169 void *argp1 = 0 ;
29170 int res1 = 0 ;
29171 void *argp2 = 0 ;
29172 int res2 = 0 ;
29173 PyObject *swig_obj[2] ;
29174
29175 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29177 if (!SWIG_IsOK(res1)) {
29178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29179 }
29180 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29181 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29182 if (!SWIG_IsOK(res2)) {
29183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29184 }
29185 arg2 = reinterpret_cast< wxColour * >(argp2);
29186 if (arg1) (arg1)->colFg = *arg2;
29187
29188 resultobj = SWIG_Py_Void();
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29196 PyObject *resultobj = 0;
29197 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29198 wxColour *result = 0 ;
29199 void *argp1 = 0 ;
29200 int res1 = 0 ;
29201 PyObject *swig_obj[1] ;
29202
29203 if (!args) SWIG_fail;
29204 swig_obj[0] = args;
29205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29206 if (!SWIG_IsOK(res1)) {
29207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29208 }
29209 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29210 result = (wxColour *)& ((arg1)->colFg);
29211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29212 return resultobj;
29213 fail:
29214 return NULL;
29215 }
29216
29217
29218 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29219 PyObject *resultobj = 0;
29220 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29221 wxColour *arg2 = (wxColour *) 0 ;
29222 void *argp1 = 0 ;
29223 int res1 = 0 ;
29224 void *argp2 = 0 ;
29225 int res2 = 0 ;
29226 PyObject *swig_obj[2] ;
29227
29228 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29230 if (!SWIG_IsOK(res1)) {
29231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29232 }
29233 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29234 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29235 if (!SWIG_IsOK(res2)) {
29236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29237 }
29238 arg2 = reinterpret_cast< wxColour * >(argp2);
29239 if (arg1) (arg1)->colBg = *arg2;
29240
29241 resultobj = SWIG_Py_Void();
29242 return resultobj;
29243 fail:
29244 return NULL;
29245 }
29246
29247
29248 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29249 PyObject *resultobj = 0;
29250 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29251 wxColour *result = 0 ;
29252 void *argp1 = 0 ;
29253 int res1 = 0 ;
29254 PyObject *swig_obj[1] ;
29255
29256 if (!args) SWIG_fail;
29257 swig_obj[0] = args;
29258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29259 if (!SWIG_IsOK(res1)) {
29260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29261 }
29262 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29263 result = (wxColour *)& ((arg1)->colBg);
29264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29265 return resultobj;
29266 fail:
29267 return NULL;
29268 }
29269
29270
29271 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29272 PyObject *obj;
29273 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29274 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29275 return SWIG_Py_Void();
29276 }
29277
29278 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29279 return SWIG_Python_InitShadowInstance(args);
29280 }
29281
29282 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29283 PyObject *resultobj = 0;
29284 wxWindow *arg1 = (wxWindow *) 0 ;
29285 int arg2 = (int) (int)-1 ;
29286 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29287 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29288 wxSize const &arg4_defvalue = wxDefaultSize ;
29289 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29290 long arg5 = (long) 0 ;
29291 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29292 wxString *arg6 = (wxString *) &arg6_defvalue ;
29293 wxWindow *result = 0 ;
29294 void *argp1 = 0 ;
29295 int res1 = 0 ;
29296 int val2 ;
29297 int ecode2 = 0 ;
29298 wxPoint temp3 ;
29299 wxSize temp4 ;
29300 long val5 ;
29301 int ecode5 = 0 ;
29302 bool temp6 = false ;
29303 PyObject * obj0 = 0 ;
29304 PyObject * obj1 = 0 ;
29305 PyObject * obj2 = 0 ;
29306 PyObject * obj3 = 0 ;
29307 PyObject * obj4 = 0 ;
29308 PyObject * obj5 = 0 ;
29309 char * kwnames[] = {
29310 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29311 };
29312
29313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29315 if (!SWIG_IsOK(res1)) {
29316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29317 }
29318 arg1 = reinterpret_cast< wxWindow * >(argp1);
29319 if (obj1) {
29320 ecode2 = SWIG_AsVal_int(obj1, &val2);
29321 if (!SWIG_IsOK(ecode2)) {
29322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29323 }
29324 arg2 = static_cast< int >(val2);
29325 }
29326 if (obj2) {
29327 {
29328 arg3 = &temp3;
29329 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29330 }
29331 }
29332 if (obj3) {
29333 {
29334 arg4 = &temp4;
29335 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29336 }
29337 }
29338 if (obj4) {
29339 ecode5 = SWIG_AsVal_long(obj4, &val5);
29340 if (!SWIG_IsOK(ecode5)) {
29341 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29342 }
29343 arg5 = static_cast< long >(val5);
29344 }
29345 if (obj5) {
29346 {
29347 arg6 = wxString_in_helper(obj5);
29348 if (arg6 == NULL) SWIG_fail;
29349 temp6 = true;
29350 }
29351 }
29352 {
29353 if (!wxPyCheckForApp()) SWIG_fail;
29354 PyThreadState* __tstate = wxPyBeginAllowThreads();
29355 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29356 wxPyEndAllowThreads(__tstate);
29357 if (PyErr_Occurred()) SWIG_fail;
29358 }
29359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29360 {
29361 if (temp6)
29362 delete arg6;
29363 }
29364 return resultobj;
29365 fail:
29366 {
29367 if (temp6)
29368 delete arg6;
29369 }
29370 return NULL;
29371 }
29372
29373
29374 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29375 PyObject *resultobj = 0;
29376 wxWindow *result = 0 ;
29377
29378 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29379 {
29380 if (!wxPyCheckForApp()) SWIG_fail;
29381 PyThreadState* __tstate = wxPyBeginAllowThreads();
29382 result = (wxWindow *)new wxWindow();
29383 wxPyEndAllowThreads(__tstate);
29384 if (PyErr_Occurred()) SWIG_fail;
29385 }
29386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29394 PyObject *resultobj = 0;
29395 wxWindow *arg1 = (wxWindow *) 0 ;
29396 wxWindow *arg2 = (wxWindow *) 0 ;
29397 int arg3 = (int) (int)-1 ;
29398 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29399 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29400 wxSize const &arg5_defvalue = wxDefaultSize ;
29401 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29402 long arg6 = (long) 0 ;
29403 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29404 wxString *arg7 = (wxString *) &arg7_defvalue ;
29405 bool result;
29406 void *argp1 = 0 ;
29407 int res1 = 0 ;
29408 void *argp2 = 0 ;
29409 int res2 = 0 ;
29410 int val3 ;
29411 int ecode3 = 0 ;
29412 wxPoint temp4 ;
29413 wxSize temp5 ;
29414 long val6 ;
29415 int ecode6 = 0 ;
29416 bool temp7 = false ;
29417 PyObject * obj0 = 0 ;
29418 PyObject * obj1 = 0 ;
29419 PyObject * obj2 = 0 ;
29420 PyObject * obj3 = 0 ;
29421 PyObject * obj4 = 0 ;
29422 PyObject * obj5 = 0 ;
29423 PyObject * obj6 = 0 ;
29424 char * kwnames[] = {
29425 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29426 };
29427
29428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29430 if (!SWIG_IsOK(res1)) {
29431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29432 }
29433 arg1 = reinterpret_cast< wxWindow * >(argp1);
29434 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29435 if (!SWIG_IsOK(res2)) {
29436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29437 }
29438 arg2 = reinterpret_cast< wxWindow * >(argp2);
29439 if (obj2) {
29440 ecode3 = SWIG_AsVal_int(obj2, &val3);
29441 if (!SWIG_IsOK(ecode3)) {
29442 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29443 }
29444 arg3 = static_cast< int >(val3);
29445 }
29446 if (obj3) {
29447 {
29448 arg4 = &temp4;
29449 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29450 }
29451 }
29452 if (obj4) {
29453 {
29454 arg5 = &temp5;
29455 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29456 }
29457 }
29458 if (obj5) {
29459 ecode6 = SWIG_AsVal_long(obj5, &val6);
29460 if (!SWIG_IsOK(ecode6)) {
29461 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29462 }
29463 arg6 = static_cast< long >(val6);
29464 }
29465 if (obj6) {
29466 {
29467 arg7 = wxString_in_helper(obj6);
29468 if (arg7 == NULL) SWIG_fail;
29469 temp7 = true;
29470 }
29471 }
29472 {
29473 PyThreadState* __tstate = wxPyBeginAllowThreads();
29474 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29475 wxPyEndAllowThreads(__tstate);
29476 if (PyErr_Occurred()) SWIG_fail;
29477 }
29478 {
29479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29480 }
29481 {
29482 if (temp7)
29483 delete arg7;
29484 }
29485 return resultobj;
29486 fail:
29487 {
29488 if (temp7)
29489 delete arg7;
29490 }
29491 return NULL;
29492 }
29493
29494
29495 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29496 PyObject *resultobj = 0;
29497 wxWindow *arg1 = (wxWindow *) 0 ;
29498 bool arg2 = (bool) false ;
29499 bool result;
29500 void *argp1 = 0 ;
29501 int res1 = 0 ;
29502 bool val2 ;
29503 int ecode2 = 0 ;
29504 PyObject * obj0 = 0 ;
29505 PyObject * obj1 = 0 ;
29506 char * kwnames[] = {
29507 (char *) "self",(char *) "force", NULL
29508 };
29509
29510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29512 if (!SWIG_IsOK(res1)) {
29513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29514 }
29515 arg1 = reinterpret_cast< wxWindow * >(argp1);
29516 if (obj1) {
29517 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29518 if (!SWIG_IsOK(ecode2)) {
29519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29520 }
29521 arg2 = static_cast< bool >(val2);
29522 }
29523 {
29524 PyThreadState* __tstate = wxPyBeginAllowThreads();
29525 result = (bool)(arg1)->Close(arg2);
29526 wxPyEndAllowThreads(__tstate);
29527 if (PyErr_Occurred()) SWIG_fail;
29528 }
29529 {
29530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29531 }
29532 return resultobj;
29533 fail:
29534 return NULL;
29535 }
29536
29537
29538 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29539 PyObject *resultobj = 0;
29540 wxWindow *arg1 = (wxWindow *) 0 ;
29541 bool result;
29542 void *argp1 = 0 ;
29543 int res1 = 0 ;
29544 PyObject *swig_obj[1] ;
29545
29546 if (!args) SWIG_fail;
29547 swig_obj[0] = args;
29548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29549 if (!SWIG_IsOK(res1)) {
29550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29551 }
29552 arg1 = reinterpret_cast< wxWindow * >(argp1);
29553 {
29554 PyThreadState* __tstate = wxPyBeginAllowThreads();
29555 result = (bool)(arg1)->Destroy();
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 {
29560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29561 }
29562 return resultobj;
29563 fail:
29564 return NULL;
29565 }
29566
29567
29568 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29569 PyObject *resultobj = 0;
29570 wxWindow *arg1 = (wxWindow *) 0 ;
29571 bool result;
29572 void *argp1 = 0 ;
29573 int res1 = 0 ;
29574 PyObject *swig_obj[1] ;
29575
29576 if (!args) SWIG_fail;
29577 swig_obj[0] = args;
29578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29579 if (!SWIG_IsOK(res1)) {
29580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29581 }
29582 arg1 = reinterpret_cast< wxWindow * >(argp1);
29583 {
29584 PyThreadState* __tstate = wxPyBeginAllowThreads();
29585 result = (bool)(arg1)->DestroyChildren();
29586 wxPyEndAllowThreads(__tstate);
29587 if (PyErr_Occurred()) SWIG_fail;
29588 }
29589 {
29590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29591 }
29592 return resultobj;
29593 fail:
29594 return NULL;
29595 }
29596
29597
29598 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29599 PyObject *resultobj = 0;
29600 wxWindow *arg1 = (wxWindow *) 0 ;
29601 bool result;
29602 void *argp1 = 0 ;
29603 int res1 = 0 ;
29604 PyObject *swig_obj[1] ;
29605
29606 if (!args) SWIG_fail;
29607 swig_obj[0] = args;
29608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29609 if (!SWIG_IsOK(res1)) {
29610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29611 }
29612 arg1 = reinterpret_cast< wxWindow * >(argp1);
29613 {
29614 PyThreadState* __tstate = wxPyBeginAllowThreads();
29615 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29616 wxPyEndAllowThreads(__tstate);
29617 if (PyErr_Occurred()) SWIG_fail;
29618 }
29619 {
29620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29621 }
29622 return resultobj;
29623 fail:
29624 return NULL;
29625 }
29626
29627
29628 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29629 PyObject *resultobj = 0;
29630 wxWindow *arg1 = (wxWindow *) 0 ;
29631 wxString *arg2 = 0 ;
29632 void *argp1 = 0 ;
29633 int res1 = 0 ;
29634 bool temp2 = false ;
29635 PyObject * obj0 = 0 ;
29636 PyObject * obj1 = 0 ;
29637 char * kwnames[] = {
29638 (char *) "self",(char *) "label", NULL
29639 };
29640
29641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29643 if (!SWIG_IsOK(res1)) {
29644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29645 }
29646 arg1 = reinterpret_cast< wxWindow * >(argp1);
29647 {
29648 arg2 = wxString_in_helper(obj1);
29649 if (arg2 == NULL) SWIG_fail;
29650 temp2 = true;
29651 }
29652 {
29653 PyThreadState* __tstate = wxPyBeginAllowThreads();
29654 (arg1)->SetLabel((wxString const &)*arg2);
29655 wxPyEndAllowThreads(__tstate);
29656 if (PyErr_Occurred()) SWIG_fail;
29657 }
29658 resultobj = SWIG_Py_Void();
29659 {
29660 if (temp2)
29661 delete arg2;
29662 }
29663 return resultobj;
29664 fail:
29665 {
29666 if (temp2)
29667 delete arg2;
29668 }
29669 return NULL;
29670 }
29671
29672
29673 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29674 PyObject *resultobj = 0;
29675 wxWindow *arg1 = (wxWindow *) 0 ;
29676 wxString result;
29677 void *argp1 = 0 ;
29678 int res1 = 0 ;
29679 PyObject *swig_obj[1] ;
29680
29681 if (!args) SWIG_fail;
29682 swig_obj[0] = args;
29683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29684 if (!SWIG_IsOK(res1)) {
29685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29686 }
29687 arg1 = reinterpret_cast< wxWindow * >(argp1);
29688 {
29689 PyThreadState* __tstate = wxPyBeginAllowThreads();
29690 result = ((wxWindow const *)arg1)->GetLabel();
29691 wxPyEndAllowThreads(__tstate);
29692 if (PyErr_Occurred()) SWIG_fail;
29693 }
29694 {
29695 #if wxUSE_UNICODE
29696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29697 #else
29698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29699 #endif
29700 }
29701 return resultobj;
29702 fail:
29703 return NULL;
29704 }
29705
29706
29707 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29708 PyObject *resultobj = 0;
29709 wxWindow *arg1 = (wxWindow *) 0 ;
29710 wxString *arg2 = 0 ;
29711 void *argp1 = 0 ;
29712 int res1 = 0 ;
29713 bool temp2 = false ;
29714 PyObject * obj0 = 0 ;
29715 PyObject * obj1 = 0 ;
29716 char * kwnames[] = {
29717 (char *) "self",(char *) "name", NULL
29718 };
29719
29720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29722 if (!SWIG_IsOK(res1)) {
29723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29724 }
29725 arg1 = reinterpret_cast< wxWindow * >(argp1);
29726 {
29727 arg2 = wxString_in_helper(obj1);
29728 if (arg2 == NULL) SWIG_fail;
29729 temp2 = true;
29730 }
29731 {
29732 PyThreadState* __tstate = wxPyBeginAllowThreads();
29733 (arg1)->SetName((wxString const &)*arg2);
29734 wxPyEndAllowThreads(__tstate);
29735 if (PyErr_Occurred()) SWIG_fail;
29736 }
29737 resultobj = SWIG_Py_Void();
29738 {
29739 if (temp2)
29740 delete arg2;
29741 }
29742 return resultobj;
29743 fail:
29744 {
29745 if (temp2)
29746 delete arg2;
29747 }
29748 return NULL;
29749 }
29750
29751
29752 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29753 PyObject *resultobj = 0;
29754 wxWindow *arg1 = (wxWindow *) 0 ;
29755 wxString result;
29756 void *argp1 = 0 ;
29757 int res1 = 0 ;
29758 PyObject *swig_obj[1] ;
29759
29760 if (!args) SWIG_fail;
29761 swig_obj[0] = args;
29762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29763 if (!SWIG_IsOK(res1)) {
29764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29765 }
29766 arg1 = reinterpret_cast< wxWindow * >(argp1);
29767 {
29768 PyThreadState* __tstate = wxPyBeginAllowThreads();
29769 result = ((wxWindow const *)arg1)->GetName();
29770 wxPyEndAllowThreads(__tstate);
29771 if (PyErr_Occurred()) SWIG_fail;
29772 }
29773 {
29774 #if wxUSE_UNICODE
29775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29776 #else
29777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29778 #endif
29779 }
29780 return resultobj;
29781 fail:
29782 return NULL;
29783 }
29784
29785
29786 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29787 PyObject *resultobj = 0;
29788 wxWindow *arg1 = (wxWindow *) 0 ;
29789 wxWindowVariant arg2 ;
29790 void *argp1 = 0 ;
29791 int res1 = 0 ;
29792 int val2 ;
29793 int ecode2 = 0 ;
29794 PyObject * obj0 = 0 ;
29795 PyObject * obj1 = 0 ;
29796 char * kwnames[] = {
29797 (char *) "self",(char *) "variant", NULL
29798 };
29799
29800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29802 if (!SWIG_IsOK(res1)) {
29803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29804 }
29805 arg1 = reinterpret_cast< wxWindow * >(argp1);
29806 ecode2 = SWIG_AsVal_int(obj1, &val2);
29807 if (!SWIG_IsOK(ecode2)) {
29808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29809 }
29810 arg2 = static_cast< wxWindowVariant >(val2);
29811 {
29812 PyThreadState* __tstate = wxPyBeginAllowThreads();
29813 (arg1)->SetWindowVariant(arg2);
29814 wxPyEndAllowThreads(__tstate);
29815 if (PyErr_Occurred()) SWIG_fail;
29816 }
29817 resultobj = SWIG_Py_Void();
29818 return resultobj;
29819 fail:
29820 return NULL;
29821 }
29822
29823
29824 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29825 PyObject *resultobj = 0;
29826 wxWindow *arg1 = (wxWindow *) 0 ;
29827 wxWindowVariant result;
29828 void *argp1 = 0 ;
29829 int res1 = 0 ;
29830 PyObject *swig_obj[1] ;
29831
29832 if (!args) SWIG_fail;
29833 swig_obj[0] = args;
29834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29835 if (!SWIG_IsOK(res1)) {
29836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29837 }
29838 arg1 = reinterpret_cast< wxWindow * >(argp1);
29839 {
29840 PyThreadState* __tstate = wxPyBeginAllowThreads();
29841 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29842 wxPyEndAllowThreads(__tstate);
29843 if (PyErr_Occurred()) SWIG_fail;
29844 }
29845 resultobj = SWIG_From_int(static_cast< int >(result));
29846 return resultobj;
29847 fail:
29848 return NULL;
29849 }
29850
29851
29852 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29853 PyObject *resultobj = 0;
29854 wxWindow *arg1 = (wxWindow *) 0 ;
29855 int arg2 ;
29856 void *argp1 = 0 ;
29857 int res1 = 0 ;
29858 int val2 ;
29859 int ecode2 = 0 ;
29860 PyObject * obj0 = 0 ;
29861 PyObject * obj1 = 0 ;
29862 char * kwnames[] = {
29863 (char *) "self",(char *) "winid", NULL
29864 };
29865
29866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29868 if (!SWIG_IsOK(res1)) {
29869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29870 }
29871 arg1 = reinterpret_cast< wxWindow * >(argp1);
29872 ecode2 = SWIG_AsVal_int(obj1, &val2);
29873 if (!SWIG_IsOK(ecode2)) {
29874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29875 }
29876 arg2 = static_cast< int >(val2);
29877 {
29878 PyThreadState* __tstate = wxPyBeginAllowThreads();
29879 (arg1)->SetId(arg2);
29880 wxPyEndAllowThreads(__tstate);
29881 if (PyErr_Occurred()) SWIG_fail;
29882 }
29883 resultobj = SWIG_Py_Void();
29884 return resultobj;
29885 fail:
29886 return NULL;
29887 }
29888
29889
29890 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29891 PyObject *resultobj = 0;
29892 wxWindow *arg1 = (wxWindow *) 0 ;
29893 int result;
29894 void *argp1 = 0 ;
29895 int res1 = 0 ;
29896 PyObject *swig_obj[1] ;
29897
29898 if (!args) SWIG_fail;
29899 swig_obj[0] = args;
29900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29901 if (!SWIG_IsOK(res1)) {
29902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29903 }
29904 arg1 = reinterpret_cast< wxWindow * >(argp1);
29905 {
29906 PyThreadState* __tstate = wxPyBeginAllowThreads();
29907 result = (int)((wxWindow const *)arg1)->GetId();
29908 wxPyEndAllowThreads(__tstate);
29909 if (PyErr_Occurred()) SWIG_fail;
29910 }
29911 resultobj = SWIG_From_int(static_cast< int >(result));
29912 return resultobj;
29913 fail:
29914 return NULL;
29915 }
29916
29917
29918 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29919 PyObject *resultobj = 0;
29920 int result;
29921
29922 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 result = (int)wxWindow::NewControlId();
29926 wxPyEndAllowThreads(__tstate);
29927 if (PyErr_Occurred()) SWIG_fail;
29928 }
29929 resultobj = SWIG_From_int(static_cast< int >(result));
29930 return resultobj;
29931 fail:
29932 return NULL;
29933 }
29934
29935
29936 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29937 PyObject *resultobj = 0;
29938 int arg1 ;
29939 int result;
29940 int val1 ;
29941 int ecode1 = 0 ;
29942 PyObject * obj0 = 0 ;
29943 char * kwnames[] = {
29944 (char *) "winid", NULL
29945 };
29946
29947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
29948 ecode1 = SWIG_AsVal_int(obj0, &val1);
29949 if (!SWIG_IsOK(ecode1)) {
29950 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
29951 }
29952 arg1 = static_cast< int >(val1);
29953 {
29954 PyThreadState* __tstate = wxPyBeginAllowThreads();
29955 result = (int)wxWindow::NextControlId(arg1);
29956 wxPyEndAllowThreads(__tstate);
29957 if (PyErr_Occurred()) SWIG_fail;
29958 }
29959 resultobj = SWIG_From_int(static_cast< int >(result));
29960 return resultobj;
29961 fail:
29962 return NULL;
29963 }
29964
29965
29966 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29967 PyObject *resultobj = 0;
29968 int arg1 ;
29969 int result;
29970 int val1 ;
29971 int ecode1 = 0 ;
29972 PyObject * obj0 = 0 ;
29973 char * kwnames[] = {
29974 (char *) "winid", NULL
29975 };
29976
29977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
29978 ecode1 = SWIG_AsVal_int(obj0, &val1);
29979 if (!SWIG_IsOK(ecode1)) {
29980 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
29981 }
29982 arg1 = static_cast< int >(val1);
29983 {
29984 PyThreadState* __tstate = wxPyBeginAllowThreads();
29985 result = (int)wxWindow::PrevControlId(arg1);
29986 wxPyEndAllowThreads(__tstate);
29987 if (PyErr_Occurred()) SWIG_fail;
29988 }
29989 resultobj = SWIG_From_int(static_cast< int >(result));
29990 return resultobj;
29991 fail:
29992 return NULL;
29993 }
29994
29995
29996 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29997 PyObject *resultobj = 0;
29998 wxWindow *arg1 = (wxWindow *) 0 ;
29999 wxSize *arg2 = 0 ;
30000 void *argp1 = 0 ;
30001 int res1 = 0 ;
30002 wxSize temp2 ;
30003 PyObject * obj0 = 0 ;
30004 PyObject * obj1 = 0 ;
30005 char * kwnames[] = {
30006 (char *) "self",(char *) "size", NULL
30007 };
30008
30009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30011 if (!SWIG_IsOK(res1)) {
30012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30013 }
30014 arg1 = reinterpret_cast< wxWindow * >(argp1);
30015 {
30016 arg2 = &temp2;
30017 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30018 }
30019 {
30020 PyThreadState* __tstate = wxPyBeginAllowThreads();
30021 (arg1)->SetSize((wxSize const &)*arg2);
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 resultobj = SWIG_Py_Void();
30026 return resultobj;
30027 fail:
30028 return NULL;
30029 }
30030
30031
30032 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30033 PyObject *resultobj = 0;
30034 wxWindow *arg1 = (wxWindow *) 0 ;
30035 int arg2 ;
30036 int arg3 ;
30037 int arg4 ;
30038 int arg5 ;
30039 int arg6 = (int) wxSIZE_AUTO ;
30040 void *argp1 = 0 ;
30041 int res1 = 0 ;
30042 int val2 ;
30043 int ecode2 = 0 ;
30044 int val3 ;
30045 int ecode3 = 0 ;
30046 int val4 ;
30047 int ecode4 = 0 ;
30048 int val5 ;
30049 int ecode5 = 0 ;
30050 int val6 ;
30051 int ecode6 = 0 ;
30052 PyObject * obj0 = 0 ;
30053 PyObject * obj1 = 0 ;
30054 PyObject * obj2 = 0 ;
30055 PyObject * obj3 = 0 ;
30056 PyObject * obj4 = 0 ;
30057 PyObject * obj5 = 0 ;
30058 char * kwnames[] = {
30059 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30060 };
30061
30062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30064 if (!SWIG_IsOK(res1)) {
30065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30066 }
30067 arg1 = reinterpret_cast< wxWindow * >(argp1);
30068 ecode2 = SWIG_AsVal_int(obj1, &val2);
30069 if (!SWIG_IsOK(ecode2)) {
30070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30071 }
30072 arg2 = static_cast< int >(val2);
30073 ecode3 = SWIG_AsVal_int(obj2, &val3);
30074 if (!SWIG_IsOK(ecode3)) {
30075 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30076 }
30077 arg3 = static_cast< int >(val3);
30078 ecode4 = SWIG_AsVal_int(obj3, &val4);
30079 if (!SWIG_IsOK(ecode4)) {
30080 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30081 }
30082 arg4 = static_cast< int >(val4);
30083 ecode5 = SWIG_AsVal_int(obj4, &val5);
30084 if (!SWIG_IsOK(ecode5)) {
30085 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30086 }
30087 arg5 = static_cast< int >(val5);
30088 if (obj5) {
30089 ecode6 = SWIG_AsVal_int(obj5, &val6);
30090 if (!SWIG_IsOK(ecode6)) {
30091 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30092 }
30093 arg6 = static_cast< int >(val6);
30094 }
30095 {
30096 PyThreadState* __tstate = wxPyBeginAllowThreads();
30097 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30098 wxPyEndAllowThreads(__tstate);
30099 if (PyErr_Occurred()) SWIG_fail;
30100 }
30101 resultobj = SWIG_Py_Void();
30102 return resultobj;
30103 fail:
30104 return NULL;
30105 }
30106
30107
30108 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30109 PyObject *resultobj = 0;
30110 wxWindow *arg1 = (wxWindow *) 0 ;
30111 wxRect *arg2 = 0 ;
30112 int arg3 = (int) wxSIZE_AUTO ;
30113 void *argp1 = 0 ;
30114 int res1 = 0 ;
30115 wxRect temp2 ;
30116 int val3 ;
30117 int ecode3 = 0 ;
30118 PyObject * obj0 = 0 ;
30119 PyObject * obj1 = 0 ;
30120 PyObject * obj2 = 0 ;
30121 char * kwnames[] = {
30122 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30123 };
30124
30125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30127 if (!SWIG_IsOK(res1)) {
30128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30129 }
30130 arg1 = reinterpret_cast< wxWindow * >(argp1);
30131 {
30132 arg2 = &temp2;
30133 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30134 }
30135 if (obj2) {
30136 ecode3 = SWIG_AsVal_int(obj2, &val3);
30137 if (!SWIG_IsOK(ecode3)) {
30138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30139 }
30140 arg3 = static_cast< int >(val3);
30141 }
30142 {
30143 PyThreadState* __tstate = wxPyBeginAllowThreads();
30144 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 resultobj = SWIG_Py_Void();
30149 return resultobj;
30150 fail:
30151 return NULL;
30152 }
30153
30154
30155 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30156 PyObject *resultobj = 0;
30157 wxWindow *arg1 = (wxWindow *) 0 ;
30158 int arg2 ;
30159 int arg3 ;
30160 void *argp1 = 0 ;
30161 int res1 = 0 ;
30162 int val2 ;
30163 int ecode2 = 0 ;
30164 int val3 ;
30165 int ecode3 = 0 ;
30166 PyObject * obj0 = 0 ;
30167 PyObject * obj1 = 0 ;
30168 PyObject * obj2 = 0 ;
30169 char * kwnames[] = {
30170 (char *) "self",(char *) "width",(char *) "height", NULL
30171 };
30172
30173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30175 if (!SWIG_IsOK(res1)) {
30176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30177 }
30178 arg1 = reinterpret_cast< wxWindow * >(argp1);
30179 ecode2 = SWIG_AsVal_int(obj1, &val2);
30180 if (!SWIG_IsOK(ecode2)) {
30181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30182 }
30183 arg2 = static_cast< int >(val2);
30184 ecode3 = SWIG_AsVal_int(obj2, &val3);
30185 if (!SWIG_IsOK(ecode3)) {
30186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30187 }
30188 arg3 = static_cast< int >(val3);
30189 {
30190 PyThreadState* __tstate = wxPyBeginAllowThreads();
30191 (arg1)->SetSize(arg2,arg3);
30192 wxPyEndAllowThreads(__tstate);
30193 if (PyErr_Occurred()) SWIG_fail;
30194 }
30195 resultobj = SWIG_Py_Void();
30196 return resultobj;
30197 fail:
30198 return NULL;
30199 }
30200
30201
30202 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30203 PyObject *resultobj = 0;
30204 wxWindow *arg1 = (wxWindow *) 0 ;
30205 wxPoint *arg2 = 0 ;
30206 int arg3 = (int) wxSIZE_USE_EXISTING ;
30207 void *argp1 = 0 ;
30208 int res1 = 0 ;
30209 wxPoint temp2 ;
30210 int val3 ;
30211 int ecode3 = 0 ;
30212 PyObject * obj0 = 0 ;
30213 PyObject * obj1 = 0 ;
30214 PyObject * obj2 = 0 ;
30215 char * kwnames[] = {
30216 (char *) "self",(char *) "pt",(char *) "flags", NULL
30217 };
30218
30219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30221 if (!SWIG_IsOK(res1)) {
30222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30223 }
30224 arg1 = reinterpret_cast< wxWindow * >(argp1);
30225 {
30226 arg2 = &temp2;
30227 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30228 }
30229 if (obj2) {
30230 ecode3 = SWIG_AsVal_int(obj2, &val3);
30231 if (!SWIG_IsOK(ecode3)) {
30232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30233 }
30234 arg3 = static_cast< int >(val3);
30235 }
30236 {
30237 PyThreadState* __tstate = wxPyBeginAllowThreads();
30238 (arg1)->Move((wxPoint const &)*arg2,arg3);
30239 wxPyEndAllowThreads(__tstate);
30240 if (PyErr_Occurred()) SWIG_fail;
30241 }
30242 resultobj = SWIG_Py_Void();
30243 return resultobj;
30244 fail:
30245 return NULL;
30246 }
30247
30248
30249 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30250 PyObject *resultobj = 0;
30251 wxWindow *arg1 = (wxWindow *) 0 ;
30252 int arg2 ;
30253 int arg3 ;
30254 int arg4 = (int) wxSIZE_USE_EXISTING ;
30255 void *argp1 = 0 ;
30256 int res1 = 0 ;
30257 int val2 ;
30258 int ecode2 = 0 ;
30259 int val3 ;
30260 int ecode3 = 0 ;
30261 int val4 ;
30262 int ecode4 = 0 ;
30263 PyObject * obj0 = 0 ;
30264 PyObject * obj1 = 0 ;
30265 PyObject * obj2 = 0 ;
30266 PyObject * obj3 = 0 ;
30267 char * kwnames[] = {
30268 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30269 };
30270
30271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30273 if (!SWIG_IsOK(res1)) {
30274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30275 }
30276 arg1 = reinterpret_cast< wxWindow * >(argp1);
30277 ecode2 = SWIG_AsVal_int(obj1, &val2);
30278 if (!SWIG_IsOK(ecode2)) {
30279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30280 }
30281 arg2 = static_cast< int >(val2);
30282 ecode3 = SWIG_AsVal_int(obj2, &val3);
30283 if (!SWIG_IsOK(ecode3)) {
30284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30285 }
30286 arg3 = static_cast< int >(val3);
30287 if (obj3) {
30288 ecode4 = SWIG_AsVal_int(obj3, &val4);
30289 if (!SWIG_IsOK(ecode4)) {
30290 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30291 }
30292 arg4 = static_cast< int >(val4);
30293 }
30294 {
30295 PyThreadState* __tstate = wxPyBeginAllowThreads();
30296 (arg1)->Move(arg2,arg3,arg4);
30297 wxPyEndAllowThreads(__tstate);
30298 if (PyErr_Occurred()) SWIG_fail;
30299 }
30300 resultobj = SWIG_Py_Void();
30301 return resultobj;
30302 fail:
30303 return NULL;
30304 }
30305
30306
30307 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30308 PyObject *resultobj = 0;
30309 wxWindow *arg1 = (wxWindow *) 0 ;
30310 wxSize const &arg2_defvalue = wxDefaultSize ;
30311 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30312 void *argp1 = 0 ;
30313 int res1 = 0 ;
30314 wxSize temp2 ;
30315 PyObject * obj0 = 0 ;
30316 PyObject * obj1 = 0 ;
30317 char * kwnames[] = {
30318 (char *) "self",(char *) "size", NULL
30319 };
30320
30321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30323 if (!SWIG_IsOK(res1)) {
30324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30325 }
30326 arg1 = reinterpret_cast< wxWindow * >(argp1);
30327 if (obj1) {
30328 {
30329 arg2 = &temp2;
30330 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30331 }
30332 }
30333 {
30334 PyThreadState* __tstate = wxPyBeginAllowThreads();
30335 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30336 wxPyEndAllowThreads(__tstate);
30337 if (PyErr_Occurred()) SWIG_fail;
30338 }
30339 resultobj = SWIG_Py_Void();
30340 return resultobj;
30341 fail:
30342 return NULL;
30343 }
30344
30345
30346 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30347 PyObject *resultobj = 0;
30348 wxWindow *arg1 = (wxWindow *) 0 ;
30349 void *argp1 = 0 ;
30350 int res1 = 0 ;
30351 PyObject *swig_obj[1] ;
30352
30353 if (!args) SWIG_fail;
30354 swig_obj[0] = args;
30355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30356 if (!SWIG_IsOK(res1)) {
30357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30358 }
30359 arg1 = reinterpret_cast< wxWindow * >(argp1);
30360 {
30361 PyThreadState* __tstate = wxPyBeginAllowThreads();
30362 (arg1)->Raise();
30363 wxPyEndAllowThreads(__tstate);
30364 if (PyErr_Occurred()) SWIG_fail;
30365 }
30366 resultobj = SWIG_Py_Void();
30367 return resultobj;
30368 fail:
30369 return NULL;
30370 }
30371
30372
30373 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30374 PyObject *resultobj = 0;
30375 wxWindow *arg1 = (wxWindow *) 0 ;
30376 void *argp1 = 0 ;
30377 int res1 = 0 ;
30378 PyObject *swig_obj[1] ;
30379
30380 if (!args) SWIG_fail;
30381 swig_obj[0] = args;
30382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30383 if (!SWIG_IsOK(res1)) {
30384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30385 }
30386 arg1 = reinterpret_cast< wxWindow * >(argp1);
30387 {
30388 PyThreadState* __tstate = wxPyBeginAllowThreads();
30389 (arg1)->Lower();
30390 wxPyEndAllowThreads(__tstate);
30391 if (PyErr_Occurred()) SWIG_fail;
30392 }
30393 resultobj = SWIG_Py_Void();
30394 return resultobj;
30395 fail:
30396 return NULL;
30397 }
30398
30399
30400 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30401 PyObject *resultobj = 0;
30402 wxWindow *arg1 = (wxWindow *) 0 ;
30403 wxSize *arg2 = 0 ;
30404 void *argp1 = 0 ;
30405 int res1 = 0 ;
30406 wxSize temp2 ;
30407 PyObject * obj0 = 0 ;
30408 PyObject * obj1 = 0 ;
30409 char * kwnames[] = {
30410 (char *) "self",(char *) "size", NULL
30411 };
30412
30413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30415 if (!SWIG_IsOK(res1)) {
30416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30417 }
30418 arg1 = reinterpret_cast< wxWindow * >(argp1);
30419 {
30420 arg2 = &temp2;
30421 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30422 }
30423 {
30424 PyThreadState* __tstate = wxPyBeginAllowThreads();
30425 (arg1)->SetClientSize((wxSize const &)*arg2);
30426 wxPyEndAllowThreads(__tstate);
30427 if (PyErr_Occurred()) SWIG_fail;
30428 }
30429 resultobj = SWIG_Py_Void();
30430 return resultobj;
30431 fail:
30432 return NULL;
30433 }
30434
30435
30436 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30437 PyObject *resultobj = 0;
30438 wxWindow *arg1 = (wxWindow *) 0 ;
30439 int arg2 ;
30440 int arg3 ;
30441 void *argp1 = 0 ;
30442 int res1 = 0 ;
30443 int val2 ;
30444 int ecode2 = 0 ;
30445 int val3 ;
30446 int ecode3 = 0 ;
30447 PyObject * obj0 = 0 ;
30448 PyObject * obj1 = 0 ;
30449 PyObject * obj2 = 0 ;
30450 char * kwnames[] = {
30451 (char *) "self",(char *) "width",(char *) "height", NULL
30452 };
30453
30454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30456 if (!SWIG_IsOK(res1)) {
30457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30458 }
30459 arg1 = reinterpret_cast< wxWindow * >(argp1);
30460 ecode2 = SWIG_AsVal_int(obj1, &val2);
30461 if (!SWIG_IsOK(ecode2)) {
30462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30463 }
30464 arg2 = static_cast< int >(val2);
30465 ecode3 = SWIG_AsVal_int(obj2, &val3);
30466 if (!SWIG_IsOK(ecode3)) {
30467 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30468 }
30469 arg3 = static_cast< int >(val3);
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 (arg1)->SetClientSize(arg2,arg3);
30473 wxPyEndAllowThreads(__tstate);
30474 if (PyErr_Occurred()) SWIG_fail;
30475 }
30476 resultobj = SWIG_Py_Void();
30477 return resultobj;
30478 fail:
30479 return NULL;
30480 }
30481
30482
30483 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30484 PyObject *resultobj = 0;
30485 wxWindow *arg1 = (wxWindow *) 0 ;
30486 wxRect *arg2 = 0 ;
30487 void *argp1 = 0 ;
30488 int res1 = 0 ;
30489 wxRect temp2 ;
30490 PyObject * obj0 = 0 ;
30491 PyObject * obj1 = 0 ;
30492 char * kwnames[] = {
30493 (char *) "self",(char *) "rect", NULL
30494 };
30495
30496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30498 if (!SWIG_IsOK(res1)) {
30499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30500 }
30501 arg1 = reinterpret_cast< wxWindow * >(argp1);
30502 {
30503 arg2 = &temp2;
30504 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30505 }
30506 {
30507 PyThreadState* __tstate = wxPyBeginAllowThreads();
30508 (arg1)->SetClientSize((wxRect const &)*arg2);
30509 wxPyEndAllowThreads(__tstate);
30510 if (PyErr_Occurred()) SWIG_fail;
30511 }
30512 resultobj = SWIG_Py_Void();
30513 return resultobj;
30514 fail:
30515 return NULL;
30516 }
30517
30518
30519 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30520 PyObject *resultobj = 0;
30521 wxWindow *arg1 = (wxWindow *) 0 ;
30522 wxPoint result;
30523 void *argp1 = 0 ;
30524 int res1 = 0 ;
30525 PyObject *swig_obj[1] ;
30526
30527 if (!args) SWIG_fail;
30528 swig_obj[0] = args;
30529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30530 if (!SWIG_IsOK(res1)) {
30531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30532 }
30533 arg1 = reinterpret_cast< wxWindow * >(argp1);
30534 {
30535 PyThreadState* __tstate = wxPyBeginAllowThreads();
30536 result = ((wxWindow const *)arg1)->GetPosition();
30537 wxPyEndAllowThreads(__tstate);
30538 if (PyErr_Occurred()) SWIG_fail;
30539 }
30540 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30541 return resultobj;
30542 fail:
30543 return NULL;
30544 }
30545
30546
30547 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30548 PyObject *resultobj = 0;
30549 wxWindow *arg1 = (wxWindow *) 0 ;
30550 int *arg2 = (int *) 0 ;
30551 int *arg3 = (int *) 0 ;
30552 void *argp1 = 0 ;
30553 int res1 = 0 ;
30554 int temp2 ;
30555 int res2 = SWIG_TMPOBJ ;
30556 int temp3 ;
30557 int res3 = SWIG_TMPOBJ ;
30558 PyObject *swig_obj[1] ;
30559
30560 arg2 = &temp2;
30561 arg3 = &temp3;
30562 if (!args) SWIG_fail;
30563 swig_obj[0] = args;
30564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30565 if (!SWIG_IsOK(res1)) {
30566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30567 }
30568 arg1 = reinterpret_cast< wxWindow * >(argp1);
30569 {
30570 PyThreadState* __tstate = wxPyBeginAllowThreads();
30571 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30572 wxPyEndAllowThreads(__tstate);
30573 if (PyErr_Occurred()) SWIG_fail;
30574 }
30575 resultobj = SWIG_Py_Void();
30576 if (SWIG_IsTmpObj(res2)) {
30577 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30578 } else {
30579 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30580 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30581 }
30582 if (SWIG_IsTmpObj(res3)) {
30583 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30584 } else {
30585 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30586 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30587 }
30588 return resultobj;
30589 fail:
30590 return NULL;
30591 }
30592
30593
30594 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30595 PyObject *resultobj = 0;
30596 wxWindow *arg1 = (wxWindow *) 0 ;
30597 wxPoint result;
30598 void *argp1 = 0 ;
30599 int res1 = 0 ;
30600 PyObject *swig_obj[1] ;
30601
30602 if (!args) SWIG_fail;
30603 swig_obj[0] = args;
30604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30605 if (!SWIG_IsOK(res1)) {
30606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30607 }
30608 arg1 = reinterpret_cast< wxWindow * >(argp1);
30609 {
30610 PyThreadState* __tstate = wxPyBeginAllowThreads();
30611 result = ((wxWindow const *)arg1)->GetScreenPosition();
30612 wxPyEndAllowThreads(__tstate);
30613 if (PyErr_Occurred()) SWIG_fail;
30614 }
30615 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30616 return resultobj;
30617 fail:
30618 return NULL;
30619 }
30620
30621
30622 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30623 PyObject *resultobj = 0;
30624 wxWindow *arg1 = (wxWindow *) 0 ;
30625 int *arg2 = (int *) 0 ;
30626 int *arg3 = (int *) 0 ;
30627 void *argp1 = 0 ;
30628 int res1 = 0 ;
30629 int temp2 ;
30630 int res2 = SWIG_TMPOBJ ;
30631 int temp3 ;
30632 int res3 = SWIG_TMPOBJ ;
30633 PyObject *swig_obj[1] ;
30634
30635 arg2 = &temp2;
30636 arg3 = &temp3;
30637 if (!args) SWIG_fail;
30638 swig_obj[0] = args;
30639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30640 if (!SWIG_IsOK(res1)) {
30641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30642 }
30643 arg1 = reinterpret_cast< wxWindow * >(argp1);
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30647 wxPyEndAllowThreads(__tstate);
30648 if (PyErr_Occurred()) SWIG_fail;
30649 }
30650 resultobj = SWIG_Py_Void();
30651 if (SWIG_IsTmpObj(res2)) {
30652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30653 } else {
30654 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30655 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30656 }
30657 if (SWIG_IsTmpObj(res3)) {
30658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30659 } else {
30660 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30662 }
30663 return resultobj;
30664 fail:
30665 return NULL;
30666 }
30667
30668
30669 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30670 PyObject *resultobj = 0;
30671 wxWindow *arg1 = (wxWindow *) 0 ;
30672 wxRect result;
30673 void *argp1 = 0 ;
30674 int res1 = 0 ;
30675 PyObject *swig_obj[1] ;
30676
30677 if (!args) SWIG_fail;
30678 swig_obj[0] = args;
30679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30680 if (!SWIG_IsOK(res1)) {
30681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30682 }
30683 arg1 = reinterpret_cast< wxWindow * >(argp1);
30684 {
30685 PyThreadState* __tstate = wxPyBeginAllowThreads();
30686 result = ((wxWindow const *)arg1)->GetScreenRect();
30687 wxPyEndAllowThreads(__tstate);
30688 if (PyErr_Occurred()) SWIG_fail;
30689 }
30690 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30691 return resultobj;
30692 fail:
30693 return NULL;
30694 }
30695
30696
30697 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30698 PyObject *resultobj = 0;
30699 wxWindow *arg1 = (wxWindow *) 0 ;
30700 wxSize result;
30701 void *argp1 = 0 ;
30702 int res1 = 0 ;
30703 PyObject *swig_obj[1] ;
30704
30705 if (!args) SWIG_fail;
30706 swig_obj[0] = args;
30707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30708 if (!SWIG_IsOK(res1)) {
30709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30710 }
30711 arg1 = reinterpret_cast< wxWindow * >(argp1);
30712 {
30713 PyThreadState* __tstate = wxPyBeginAllowThreads();
30714 result = ((wxWindow const *)arg1)->GetSize();
30715 wxPyEndAllowThreads(__tstate);
30716 if (PyErr_Occurred()) SWIG_fail;
30717 }
30718 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30719 return resultobj;
30720 fail:
30721 return NULL;
30722 }
30723
30724
30725 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30726 PyObject *resultobj = 0;
30727 wxWindow *arg1 = (wxWindow *) 0 ;
30728 int *arg2 = (int *) 0 ;
30729 int *arg3 = (int *) 0 ;
30730 void *argp1 = 0 ;
30731 int res1 = 0 ;
30732 int temp2 ;
30733 int res2 = SWIG_TMPOBJ ;
30734 int temp3 ;
30735 int res3 = SWIG_TMPOBJ ;
30736 PyObject *swig_obj[1] ;
30737
30738 arg2 = &temp2;
30739 arg3 = &temp3;
30740 if (!args) SWIG_fail;
30741 swig_obj[0] = args;
30742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30743 if (!SWIG_IsOK(res1)) {
30744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30745 }
30746 arg1 = reinterpret_cast< wxWindow * >(argp1);
30747 {
30748 PyThreadState* __tstate = wxPyBeginAllowThreads();
30749 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30750 wxPyEndAllowThreads(__tstate);
30751 if (PyErr_Occurred()) SWIG_fail;
30752 }
30753 resultobj = SWIG_Py_Void();
30754 if (SWIG_IsTmpObj(res2)) {
30755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30756 } else {
30757 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30758 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30759 }
30760 if (SWIG_IsTmpObj(res3)) {
30761 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30762 } else {
30763 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30764 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30765 }
30766 return resultobj;
30767 fail:
30768 return NULL;
30769 }
30770
30771
30772 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30773 PyObject *resultobj = 0;
30774 wxWindow *arg1 = (wxWindow *) 0 ;
30775 wxRect result;
30776 void *argp1 = 0 ;
30777 int res1 = 0 ;
30778 PyObject *swig_obj[1] ;
30779
30780 if (!args) SWIG_fail;
30781 swig_obj[0] = args;
30782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30783 if (!SWIG_IsOK(res1)) {
30784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30785 }
30786 arg1 = reinterpret_cast< wxWindow * >(argp1);
30787 {
30788 PyThreadState* __tstate = wxPyBeginAllowThreads();
30789 result = ((wxWindow const *)arg1)->GetRect();
30790 wxPyEndAllowThreads(__tstate);
30791 if (PyErr_Occurred()) SWIG_fail;
30792 }
30793 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30794 return resultobj;
30795 fail:
30796 return NULL;
30797 }
30798
30799
30800 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30801 PyObject *resultobj = 0;
30802 wxWindow *arg1 = (wxWindow *) 0 ;
30803 wxSize result;
30804 void *argp1 = 0 ;
30805 int res1 = 0 ;
30806 PyObject *swig_obj[1] ;
30807
30808 if (!args) SWIG_fail;
30809 swig_obj[0] = args;
30810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30811 if (!SWIG_IsOK(res1)) {
30812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30813 }
30814 arg1 = reinterpret_cast< wxWindow * >(argp1);
30815 {
30816 PyThreadState* __tstate = wxPyBeginAllowThreads();
30817 result = ((wxWindow const *)arg1)->GetClientSize();
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30822 return resultobj;
30823 fail:
30824 return NULL;
30825 }
30826
30827
30828 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30829 PyObject *resultobj = 0;
30830 wxWindow *arg1 = (wxWindow *) 0 ;
30831 int *arg2 = (int *) 0 ;
30832 int *arg3 = (int *) 0 ;
30833 void *argp1 = 0 ;
30834 int res1 = 0 ;
30835 int temp2 ;
30836 int res2 = SWIG_TMPOBJ ;
30837 int temp3 ;
30838 int res3 = SWIG_TMPOBJ ;
30839 PyObject *swig_obj[1] ;
30840
30841 arg2 = &temp2;
30842 arg3 = &temp3;
30843 if (!args) SWIG_fail;
30844 swig_obj[0] = args;
30845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30846 if (!SWIG_IsOK(res1)) {
30847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30848 }
30849 arg1 = reinterpret_cast< wxWindow * >(argp1);
30850 {
30851 PyThreadState* __tstate = wxPyBeginAllowThreads();
30852 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30853 wxPyEndAllowThreads(__tstate);
30854 if (PyErr_Occurred()) SWIG_fail;
30855 }
30856 resultobj = SWIG_Py_Void();
30857 if (SWIG_IsTmpObj(res2)) {
30858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30859 } else {
30860 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30862 }
30863 if (SWIG_IsTmpObj(res3)) {
30864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30865 } else {
30866 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30868 }
30869 return resultobj;
30870 fail:
30871 return NULL;
30872 }
30873
30874
30875 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30876 PyObject *resultobj = 0;
30877 wxWindow *arg1 = (wxWindow *) 0 ;
30878 wxPoint result;
30879 void *argp1 = 0 ;
30880 int res1 = 0 ;
30881 PyObject *swig_obj[1] ;
30882
30883 if (!args) SWIG_fail;
30884 swig_obj[0] = args;
30885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30886 if (!SWIG_IsOK(res1)) {
30887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30888 }
30889 arg1 = reinterpret_cast< wxWindow * >(argp1);
30890 {
30891 PyThreadState* __tstate = wxPyBeginAllowThreads();
30892 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30893 wxPyEndAllowThreads(__tstate);
30894 if (PyErr_Occurred()) SWIG_fail;
30895 }
30896 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30897 return resultobj;
30898 fail:
30899 return NULL;
30900 }
30901
30902
30903 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30904 PyObject *resultobj = 0;
30905 wxWindow *arg1 = (wxWindow *) 0 ;
30906 wxRect result;
30907 void *argp1 = 0 ;
30908 int res1 = 0 ;
30909 PyObject *swig_obj[1] ;
30910
30911 if (!args) SWIG_fail;
30912 swig_obj[0] = args;
30913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30914 if (!SWIG_IsOK(res1)) {
30915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30916 }
30917 arg1 = reinterpret_cast< wxWindow * >(argp1);
30918 {
30919 PyThreadState* __tstate = wxPyBeginAllowThreads();
30920 result = ((wxWindow const *)arg1)->GetClientRect();
30921 wxPyEndAllowThreads(__tstate);
30922 if (PyErr_Occurred()) SWIG_fail;
30923 }
30924 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30925 return resultobj;
30926 fail:
30927 return NULL;
30928 }
30929
30930
30931 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30932 PyObject *resultobj = 0;
30933 wxWindow *arg1 = (wxWindow *) 0 ;
30934 wxSize result;
30935 void *argp1 = 0 ;
30936 int res1 = 0 ;
30937 PyObject *swig_obj[1] ;
30938
30939 if (!args) SWIG_fail;
30940 swig_obj[0] = args;
30941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30942 if (!SWIG_IsOK(res1)) {
30943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30944 }
30945 arg1 = reinterpret_cast< wxWindow * >(argp1);
30946 {
30947 PyThreadState* __tstate = wxPyBeginAllowThreads();
30948 result = ((wxWindow const *)arg1)->GetBestSize();
30949 wxPyEndAllowThreads(__tstate);
30950 if (PyErr_Occurred()) SWIG_fail;
30951 }
30952 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30953 return resultobj;
30954 fail:
30955 return NULL;
30956 }
30957
30958
30959 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30960 PyObject *resultobj = 0;
30961 wxWindow *arg1 = (wxWindow *) 0 ;
30962 int *arg2 = (int *) 0 ;
30963 int *arg3 = (int *) 0 ;
30964 void *argp1 = 0 ;
30965 int res1 = 0 ;
30966 int temp2 ;
30967 int res2 = SWIG_TMPOBJ ;
30968 int temp3 ;
30969 int res3 = SWIG_TMPOBJ ;
30970 PyObject *swig_obj[1] ;
30971
30972 arg2 = &temp2;
30973 arg3 = &temp3;
30974 if (!args) SWIG_fail;
30975 swig_obj[0] = args;
30976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30977 if (!SWIG_IsOK(res1)) {
30978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30979 }
30980 arg1 = reinterpret_cast< wxWindow * >(argp1);
30981 {
30982 PyThreadState* __tstate = wxPyBeginAllowThreads();
30983 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
30984 wxPyEndAllowThreads(__tstate);
30985 if (PyErr_Occurred()) SWIG_fail;
30986 }
30987 resultobj = SWIG_Py_Void();
30988 if (SWIG_IsTmpObj(res2)) {
30989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30990 } else {
30991 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30993 }
30994 if (SWIG_IsTmpObj(res3)) {
30995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30996 } else {
30997 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30999 }
31000 return resultobj;
31001 fail:
31002 return NULL;
31003 }
31004
31005
31006 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31007 PyObject *resultobj = 0;
31008 wxWindow *arg1 = (wxWindow *) 0 ;
31009 void *argp1 = 0 ;
31010 int res1 = 0 ;
31011 PyObject *swig_obj[1] ;
31012
31013 if (!args) SWIG_fail;
31014 swig_obj[0] = args;
31015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31016 if (!SWIG_IsOK(res1)) {
31017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31018 }
31019 arg1 = reinterpret_cast< wxWindow * >(argp1);
31020 {
31021 PyThreadState* __tstate = wxPyBeginAllowThreads();
31022 (arg1)->InvalidateBestSize();
31023 wxPyEndAllowThreads(__tstate);
31024 if (PyErr_Occurred()) SWIG_fail;
31025 }
31026 resultobj = SWIG_Py_Void();
31027 return resultobj;
31028 fail:
31029 return NULL;
31030 }
31031
31032
31033 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31034 PyObject *resultobj = 0;
31035 wxWindow *arg1 = (wxWindow *) 0 ;
31036 wxSize *arg2 = 0 ;
31037 void *argp1 = 0 ;
31038 int res1 = 0 ;
31039 wxSize temp2 ;
31040 PyObject * obj0 = 0 ;
31041 PyObject * obj1 = 0 ;
31042 char * kwnames[] = {
31043 (char *) "self",(char *) "size", NULL
31044 };
31045
31046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31048 if (!SWIG_IsOK(res1)) {
31049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31050 }
31051 arg1 = reinterpret_cast< wxWindow * >(argp1);
31052 {
31053 arg2 = &temp2;
31054 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31055 }
31056 {
31057 PyThreadState* __tstate = wxPyBeginAllowThreads();
31058 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31059 wxPyEndAllowThreads(__tstate);
31060 if (PyErr_Occurred()) SWIG_fail;
31061 }
31062 resultobj = SWIG_Py_Void();
31063 return resultobj;
31064 fail:
31065 return NULL;
31066 }
31067
31068
31069 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31070 PyObject *resultobj = 0;
31071 wxWindow *arg1 = (wxWindow *) 0 ;
31072 wxSize result;
31073 void *argp1 = 0 ;
31074 int res1 = 0 ;
31075 PyObject *swig_obj[1] ;
31076
31077 if (!args) SWIG_fail;
31078 swig_obj[0] = args;
31079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31080 if (!SWIG_IsOK(res1)) {
31081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31082 }
31083 arg1 = reinterpret_cast< wxWindow * >(argp1);
31084 {
31085 PyThreadState* __tstate = wxPyBeginAllowThreads();
31086 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31087 wxPyEndAllowThreads(__tstate);
31088 if (PyErr_Occurred()) SWIG_fail;
31089 }
31090 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31091 return resultobj;
31092 fail:
31093 return NULL;
31094 }
31095
31096
31097 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31098 PyObject *resultobj = 0;
31099 wxWindow *arg1 = (wxWindow *) 0 ;
31100 wxSize result;
31101 void *argp1 = 0 ;
31102 int res1 = 0 ;
31103 PyObject *swig_obj[1] ;
31104
31105 if (!args) SWIG_fail;
31106 swig_obj[0] = args;
31107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31108 if (!SWIG_IsOK(res1)) {
31109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31110 }
31111 arg1 = reinterpret_cast< wxWindow * >(argp1);
31112 {
31113 PyThreadState* __tstate = wxPyBeginAllowThreads();
31114 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31115 wxPyEndAllowThreads(__tstate);
31116 if (PyErr_Occurred()) SWIG_fail;
31117 }
31118 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31119 return resultobj;
31120 fail:
31121 return NULL;
31122 }
31123
31124
31125 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31126 PyObject *resultobj = 0;
31127 wxWindow *arg1 = (wxWindow *) 0 ;
31128 int arg2 = (int) wxBOTH ;
31129 void *argp1 = 0 ;
31130 int res1 = 0 ;
31131 int val2 ;
31132 int ecode2 = 0 ;
31133 PyObject * obj0 = 0 ;
31134 PyObject * obj1 = 0 ;
31135 char * kwnames[] = {
31136 (char *) "self",(char *) "direction", NULL
31137 };
31138
31139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31141 if (!SWIG_IsOK(res1)) {
31142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31143 }
31144 arg1 = reinterpret_cast< wxWindow * >(argp1);
31145 if (obj1) {
31146 ecode2 = SWIG_AsVal_int(obj1, &val2);
31147 if (!SWIG_IsOK(ecode2)) {
31148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31149 }
31150 arg2 = static_cast< int >(val2);
31151 }
31152 {
31153 PyThreadState* __tstate = wxPyBeginAllowThreads();
31154 (arg1)->Center(arg2);
31155 wxPyEndAllowThreads(__tstate);
31156 if (PyErr_Occurred()) SWIG_fail;
31157 }
31158 resultobj = SWIG_Py_Void();
31159 return resultobj;
31160 fail:
31161 return NULL;
31162 }
31163
31164
31165 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31166 PyObject *resultobj = 0;
31167 wxWindow *arg1 = (wxWindow *) 0 ;
31168 int arg2 = (int) wxBOTH ;
31169 void *argp1 = 0 ;
31170 int res1 = 0 ;
31171 int val2 ;
31172 int ecode2 = 0 ;
31173 PyObject * obj0 = 0 ;
31174 PyObject * obj1 = 0 ;
31175 char * kwnames[] = {
31176 (char *) "self",(char *) "dir", NULL
31177 };
31178
31179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31181 if (!SWIG_IsOK(res1)) {
31182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31183 }
31184 arg1 = reinterpret_cast< wxWindow * >(argp1);
31185 if (obj1) {
31186 ecode2 = SWIG_AsVal_int(obj1, &val2);
31187 if (!SWIG_IsOK(ecode2)) {
31188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31189 }
31190 arg2 = static_cast< int >(val2);
31191 }
31192 {
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 (arg1)->CenterOnParent(arg2);
31195 wxPyEndAllowThreads(__tstate);
31196 if (PyErr_Occurred()) SWIG_fail;
31197 }
31198 resultobj = SWIG_Py_Void();
31199 return resultobj;
31200 fail:
31201 return NULL;
31202 }
31203
31204
31205 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31206 PyObject *resultobj = 0;
31207 wxWindow *arg1 = (wxWindow *) 0 ;
31208 void *argp1 = 0 ;
31209 int res1 = 0 ;
31210 PyObject *swig_obj[1] ;
31211
31212 if (!args) SWIG_fail;
31213 swig_obj[0] = args;
31214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31215 if (!SWIG_IsOK(res1)) {
31216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31217 }
31218 arg1 = reinterpret_cast< wxWindow * >(argp1);
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 (arg1)->Fit();
31222 wxPyEndAllowThreads(__tstate);
31223 if (PyErr_Occurred()) SWIG_fail;
31224 }
31225 resultobj = SWIG_Py_Void();
31226 return resultobj;
31227 fail:
31228 return NULL;
31229 }
31230
31231
31232 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31233 PyObject *resultobj = 0;
31234 wxWindow *arg1 = (wxWindow *) 0 ;
31235 void *argp1 = 0 ;
31236 int res1 = 0 ;
31237 PyObject *swig_obj[1] ;
31238
31239 if (!args) SWIG_fail;
31240 swig_obj[0] = args;
31241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31242 if (!SWIG_IsOK(res1)) {
31243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31244 }
31245 arg1 = reinterpret_cast< wxWindow * >(argp1);
31246 {
31247 PyThreadState* __tstate = wxPyBeginAllowThreads();
31248 (arg1)->FitInside();
31249 wxPyEndAllowThreads(__tstate);
31250 if (PyErr_Occurred()) SWIG_fail;
31251 }
31252 resultobj = SWIG_Py_Void();
31253 return resultobj;
31254 fail:
31255 return NULL;
31256 }
31257
31258
31259 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31260 PyObject *resultobj = 0;
31261 wxWindow *arg1 = (wxWindow *) 0 ;
31262 int arg2 ;
31263 int arg3 ;
31264 int arg4 = (int) -1 ;
31265 int arg5 = (int) -1 ;
31266 int arg6 = (int) -1 ;
31267 int arg7 = (int) -1 ;
31268 void *argp1 = 0 ;
31269 int res1 = 0 ;
31270 int val2 ;
31271 int ecode2 = 0 ;
31272 int val3 ;
31273 int ecode3 = 0 ;
31274 int val4 ;
31275 int ecode4 = 0 ;
31276 int val5 ;
31277 int ecode5 = 0 ;
31278 int val6 ;
31279 int ecode6 = 0 ;
31280 int val7 ;
31281 int ecode7 = 0 ;
31282 PyObject * obj0 = 0 ;
31283 PyObject * obj1 = 0 ;
31284 PyObject * obj2 = 0 ;
31285 PyObject * obj3 = 0 ;
31286 PyObject * obj4 = 0 ;
31287 PyObject * obj5 = 0 ;
31288 PyObject * obj6 = 0 ;
31289 char * kwnames[] = {
31290 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31291 };
31292
31293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31295 if (!SWIG_IsOK(res1)) {
31296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31297 }
31298 arg1 = reinterpret_cast< wxWindow * >(argp1);
31299 ecode2 = SWIG_AsVal_int(obj1, &val2);
31300 if (!SWIG_IsOK(ecode2)) {
31301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31302 }
31303 arg2 = static_cast< int >(val2);
31304 ecode3 = SWIG_AsVal_int(obj2, &val3);
31305 if (!SWIG_IsOK(ecode3)) {
31306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31307 }
31308 arg3 = static_cast< int >(val3);
31309 if (obj3) {
31310 ecode4 = SWIG_AsVal_int(obj3, &val4);
31311 if (!SWIG_IsOK(ecode4)) {
31312 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31313 }
31314 arg4 = static_cast< int >(val4);
31315 }
31316 if (obj4) {
31317 ecode5 = SWIG_AsVal_int(obj4, &val5);
31318 if (!SWIG_IsOK(ecode5)) {
31319 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31320 }
31321 arg5 = static_cast< int >(val5);
31322 }
31323 if (obj5) {
31324 ecode6 = SWIG_AsVal_int(obj5, &val6);
31325 if (!SWIG_IsOK(ecode6)) {
31326 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31327 }
31328 arg6 = static_cast< int >(val6);
31329 }
31330 if (obj6) {
31331 ecode7 = SWIG_AsVal_int(obj6, &val7);
31332 if (!SWIG_IsOK(ecode7)) {
31333 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31334 }
31335 arg7 = static_cast< int >(val7);
31336 }
31337 {
31338 PyThreadState* __tstate = wxPyBeginAllowThreads();
31339 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31340 wxPyEndAllowThreads(__tstate);
31341 if (PyErr_Occurred()) SWIG_fail;
31342 }
31343 resultobj = SWIG_Py_Void();
31344 return resultobj;
31345 fail:
31346 return NULL;
31347 }
31348
31349
31350 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31351 PyObject *resultobj = 0;
31352 wxWindow *arg1 = (wxWindow *) 0 ;
31353 wxSize *arg2 = 0 ;
31354 wxSize const &arg3_defvalue = wxDefaultSize ;
31355 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31356 wxSize const &arg4_defvalue = wxDefaultSize ;
31357 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31358 void *argp1 = 0 ;
31359 int res1 = 0 ;
31360 wxSize temp2 ;
31361 wxSize temp3 ;
31362 wxSize temp4 ;
31363 PyObject * obj0 = 0 ;
31364 PyObject * obj1 = 0 ;
31365 PyObject * obj2 = 0 ;
31366 PyObject * obj3 = 0 ;
31367 char * kwnames[] = {
31368 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31369 };
31370
31371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31373 if (!SWIG_IsOK(res1)) {
31374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31375 }
31376 arg1 = reinterpret_cast< wxWindow * >(argp1);
31377 {
31378 arg2 = &temp2;
31379 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31380 }
31381 if (obj2) {
31382 {
31383 arg3 = &temp3;
31384 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31385 }
31386 }
31387 if (obj3) {
31388 {
31389 arg4 = &temp4;
31390 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31391 }
31392 }
31393 {
31394 PyThreadState* __tstate = wxPyBeginAllowThreads();
31395 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31396 wxPyEndAllowThreads(__tstate);
31397 if (PyErr_Occurred()) SWIG_fail;
31398 }
31399 resultobj = SWIG_Py_Void();
31400 return resultobj;
31401 fail:
31402 return NULL;
31403 }
31404
31405
31406 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31407 PyObject *resultobj = 0;
31408 wxWindow *arg1 = (wxWindow *) 0 ;
31409 int arg2 ;
31410 int arg3 ;
31411 int arg4 = (int) -1 ;
31412 int arg5 = (int) -1 ;
31413 void *argp1 = 0 ;
31414 int res1 = 0 ;
31415 int val2 ;
31416 int ecode2 = 0 ;
31417 int val3 ;
31418 int ecode3 = 0 ;
31419 int val4 ;
31420 int ecode4 = 0 ;
31421 int val5 ;
31422 int ecode5 = 0 ;
31423 PyObject * obj0 = 0 ;
31424 PyObject * obj1 = 0 ;
31425 PyObject * obj2 = 0 ;
31426 PyObject * obj3 = 0 ;
31427 PyObject * obj4 = 0 ;
31428 char * kwnames[] = {
31429 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31430 };
31431
31432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31434 if (!SWIG_IsOK(res1)) {
31435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31436 }
31437 arg1 = reinterpret_cast< wxWindow * >(argp1);
31438 ecode2 = SWIG_AsVal_int(obj1, &val2);
31439 if (!SWIG_IsOK(ecode2)) {
31440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31441 }
31442 arg2 = static_cast< int >(val2);
31443 ecode3 = SWIG_AsVal_int(obj2, &val3);
31444 if (!SWIG_IsOK(ecode3)) {
31445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31446 }
31447 arg3 = static_cast< int >(val3);
31448 if (obj3) {
31449 ecode4 = SWIG_AsVal_int(obj3, &val4);
31450 if (!SWIG_IsOK(ecode4)) {
31451 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31452 }
31453 arg4 = static_cast< int >(val4);
31454 }
31455 if (obj4) {
31456 ecode5 = SWIG_AsVal_int(obj4, &val5);
31457 if (!SWIG_IsOK(ecode5)) {
31458 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31459 }
31460 arg5 = static_cast< int >(val5);
31461 }
31462 {
31463 PyThreadState* __tstate = wxPyBeginAllowThreads();
31464 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31465 wxPyEndAllowThreads(__tstate);
31466 if (PyErr_Occurred()) SWIG_fail;
31467 }
31468 resultobj = SWIG_Py_Void();
31469 return resultobj;
31470 fail:
31471 return NULL;
31472 }
31473
31474
31475 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31476 PyObject *resultobj = 0;
31477 wxWindow *arg1 = (wxWindow *) 0 ;
31478 wxSize *arg2 = 0 ;
31479 wxSize const &arg3_defvalue = wxDefaultSize ;
31480 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31481 void *argp1 = 0 ;
31482 int res1 = 0 ;
31483 wxSize temp2 ;
31484 wxSize temp3 ;
31485 PyObject * obj0 = 0 ;
31486 PyObject * obj1 = 0 ;
31487 PyObject * obj2 = 0 ;
31488 char * kwnames[] = {
31489 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31490 };
31491
31492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31494 if (!SWIG_IsOK(res1)) {
31495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31496 }
31497 arg1 = reinterpret_cast< wxWindow * >(argp1);
31498 {
31499 arg2 = &temp2;
31500 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31501 }
31502 if (obj2) {
31503 {
31504 arg3 = &temp3;
31505 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31506 }
31507 }
31508 {
31509 PyThreadState* __tstate = wxPyBeginAllowThreads();
31510 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31511 wxPyEndAllowThreads(__tstate);
31512 if (PyErr_Occurred()) SWIG_fail;
31513 }
31514 resultobj = SWIG_Py_Void();
31515 return resultobj;
31516 fail:
31517 return NULL;
31518 }
31519
31520
31521 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31522 PyObject *resultobj = 0;
31523 wxWindow *arg1 = (wxWindow *) 0 ;
31524 wxSize result;
31525 void *argp1 = 0 ;
31526 int res1 = 0 ;
31527 PyObject *swig_obj[1] ;
31528
31529 if (!args) SWIG_fail;
31530 swig_obj[0] = args;
31531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31532 if (!SWIG_IsOK(res1)) {
31533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31534 }
31535 arg1 = reinterpret_cast< wxWindow * >(argp1);
31536 {
31537 PyThreadState* __tstate = wxPyBeginAllowThreads();
31538 result = ((wxWindow const *)arg1)->GetMaxSize();
31539 wxPyEndAllowThreads(__tstate);
31540 if (PyErr_Occurred()) SWIG_fail;
31541 }
31542 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31543 return resultobj;
31544 fail:
31545 return NULL;
31546 }
31547
31548
31549 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31550 PyObject *resultobj = 0;
31551 wxWindow *arg1 = (wxWindow *) 0 ;
31552 wxSize result;
31553 void *argp1 = 0 ;
31554 int res1 = 0 ;
31555 PyObject *swig_obj[1] ;
31556
31557 if (!args) SWIG_fail;
31558 swig_obj[0] = args;
31559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31560 if (!SWIG_IsOK(res1)) {
31561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31562 }
31563 arg1 = reinterpret_cast< wxWindow * >(argp1);
31564 {
31565 PyThreadState* __tstate = wxPyBeginAllowThreads();
31566 result = ((wxWindow const *)arg1)->GetMinSize();
31567 wxPyEndAllowThreads(__tstate);
31568 if (PyErr_Occurred()) SWIG_fail;
31569 }
31570 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31571 return resultobj;
31572 fail:
31573 return NULL;
31574 }
31575
31576
31577 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31578 PyObject *resultobj = 0;
31579 wxWindow *arg1 = (wxWindow *) 0 ;
31580 wxSize *arg2 = 0 ;
31581 void *argp1 = 0 ;
31582 int res1 = 0 ;
31583 wxSize temp2 ;
31584 PyObject * obj0 = 0 ;
31585 PyObject * obj1 = 0 ;
31586 char * kwnames[] = {
31587 (char *) "self",(char *) "minSize", NULL
31588 };
31589
31590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31592 if (!SWIG_IsOK(res1)) {
31593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31594 }
31595 arg1 = reinterpret_cast< wxWindow * >(argp1);
31596 {
31597 arg2 = &temp2;
31598 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31599 }
31600 {
31601 PyThreadState* __tstate = wxPyBeginAllowThreads();
31602 (arg1)->SetMinSize((wxSize const &)*arg2);
31603 wxPyEndAllowThreads(__tstate);
31604 if (PyErr_Occurred()) SWIG_fail;
31605 }
31606 resultobj = SWIG_Py_Void();
31607 return resultobj;
31608 fail:
31609 return NULL;
31610 }
31611
31612
31613 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31614 PyObject *resultobj = 0;
31615 wxWindow *arg1 = (wxWindow *) 0 ;
31616 wxSize *arg2 = 0 ;
31617 void *argp1 = 0 ;
31618 int res1 = 0 ;
31619 wxSize temp2 ;
31620 PyObject * obj0 = 0 ;
31621 PyObject * obj1 = 0 ;
31622 char * kwnames[] = {
31623 (char *) "self",(char *) "maxSize", NULL
31624 };
31625
31626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31628 if (!SWIG_IsOK(res1)) {
31629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31630 }
31631 arg1 = reinterpret_cast< wxWindow * >(argp1);
31632 {
31633 arg2 = &temp2;
31634 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31635 }
31636 {
31637 PyThreadState* __tstate = wxPyBeginAllowThreads();
31638 (arg1)->SetMaxSize((wxSize const &)*arg2);
31639 wxPyEndAllowThreads(__tstate);
31640 if (PyErr_Occurred()) SWIG_fail;
31641 }
31642 resultobj = SWIG_Py_Void();
31643 return resultobj;
31644 fail:
31645 return NULL;
31646 }
31647
31648
31649 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31650 PyObject *resultobj = 0;
31651 wxWindow *arg1 = (wxWindow *) 0 ;
31652 int result;
31653 void *argp1 = 0 ;
31654 int res1 = 0 ;
31655 PyObject *swig_obj[1] ;
31656
31657 if (!args) SWIG_fail;
31658 swig_obj[0] = args;
31659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31660 if (!SWIG_IsOK(res1)) {
31661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31662 }
31663 arg1 = reinterpret_cast< wxWindow * >(argp1);
31664 {
31665 PyThreadState* __tstate = wxPyBeginAllowThreads();
31666 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31667 wxPyEndAllowThreads(__tstate);
31668 if (PyErr_Occurred()) SWIG_fail;
31669 }
31670 resultobj = SWIG_From_int(static_cast< int >(result));
31671 return resultobj;
31672 fail:
31673 return NULL;
31674 }
31675
31676
31677 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31678 PyObject *resultobj = 0;
31679 wxWindow *arg1 = (wxWindow *) 0 ;
31680 int result;
31681 void *argp1 = 0 ;
31682 int res1 = 0 ;
31683 PyObject *swig_obj[1] ;
31684
31685 if (!args) SWIG_fail;
31686 swig_obj[0] = args;
31687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31688 if (!SWIG_IsOK(res1)) {
31689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31690 }
31691 arg1 = reinterpret_cast< wxWindow * >(argp1);
31692 {
31693 PyThreadState* __tstate = wxPyBeginAllowThreads();
31694 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31695 wxPyEndAllowThreads(__tstate);
31696 if (PyErr_Occurred()) SWIG_fail;
31697 }
31698 resultobj = SWIG_From_int(static_cast< int >(result));
31699 return resultobj;
31700 fail:
31701 return NULL;
31702 }
31703
31704
31705 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31706 PyObject *resultobj = 0;
31707 wxWindow *arg1 = (wxWindow *) 0 ;
31708 int result;
31709 void *argp1 = 0 ;
31710 int res1 = 0 ;
31711 PyObject *swig_obj[1] ;
31712
31713 if (!args) SWIG_fail;
31714 swig_obj[0] = args;
31715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31716 if (!SWIG_IsOK(res1)) {
31717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31718 }
31719 arg1 = reinterpret_cast< wxWindow * >(argp1);
31720 {
31721 PyThreadState* __tstate = wxPyBeginAllowThreads();
31722 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31723 wxPyEndAllowThreads(__tstate);
31724 if (PyErr_Occurred()) SWIG_fail;
31725 }
31726 resultobj = SWIG_From_int(static_cast< int >(result));
31727 return resultobj;
31728 fail:
31729 return NULL;
31730 }
31731
31732
31733 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31734 PyObject *resultobj = 0;
31735 wxWindow *arg1 = (wxWindow *) 0 ;
31736 int result;
31737 void *argp1 = 0 ;
31738 int res1 = 0 ;
31739 PyObject *swig_obj[1] ;
31740
31741 if (!args) SWIG_fail;
31742 swig_obj[0] = args;
31743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31744 if (!SWIG_IsOK(res1)) {
31745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31746 }
31747 arg1 = reinterpret_cast< wxWindow * >(argp1);
31748 {
31749 PyThreadState* __tstate = wxPyBeginAllowThreads();
31750 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31751 wxPyEndAllowThreads(__tstate);
31752 if (PyErr_Occurred()) SWIG_fail;
31753 }
31754 resultobj = SWIG_From_int(static_cast< int >(result));
31755 return resultobj;
31756 fail:
31757 return NULL;
31758 }
31759
31760
31761 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31762 PyObject *resultobj = 0;
31763 wxWindow *arg1 = (wxWindow *) 0 ;
31764 wxSize *arg2 = 0 ;
31765 void *argp1 = 0 ;
31766 int res1 = 0 ;
31767 wxSize temp2 ;
31768 PyObject * obj0 = 0 ;
31769 PyObject * obj1 = 0 ;
31770 char * kwnames[] = {
31771 (char *) "self",(char *) "size", NULL
31772 };
31773
31774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31776 if (!SWIG_IsOK(res1)) {
31777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31778 }
31779 arg1 = reinterpret_cast< wxWindow * >(argp1);
31780 {
31781 arg2 = &temp2;
31782 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31783 }
31784 {
31785 PyThreadState* __tstate = wxPyBeginAllowThreads();
31786 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31787 wxPyEndAllowThreads(__tstate);
31788 if (PyErr_Occurred()) SWIG_fail;
31789 }
31790 resultobj = SWIG_Py_Void();
31791 return resultobj;
31792 fail:
31793 return NULL;
31794 }
31795
31796
31797 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31798 PyObject *resultobj = 0;
31799 wxWindow *arg1 = (wxWindow *) 0 ;
31800 int arg2 ;
31801 int arg3 ;
31802 void *argp1 = 0 ;
31803 int res1 = 0 ;
31804 int val2 ;
31805 int ecode2 = 0 ;
31806 int val3 ;
31807 int ecode3 = 0 ;
31808 PyObject * obj0 = 0 ;
31809 PyObject * obj1 = 0 ;
31810 PyObject * obj2 = 0 ;
31811 char * kwnames[] = {
31812 (char *) "self",(char *) "w",(char *) "h", NULL
31813 };
31814
31815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31817 if (!SWIG_IsOK(res1)) {
31818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31819 }
31820 arg1 = reinterpret_cast< wxWindow * >(argp1);
31821 ecode2 = SWIG_AsVal_int(obj1, &val2);
31822 if (!SWIG_IsOK(ecode2)) {
31823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31824 }
31825 arg2 = static_cast< int >(val2);
31826 ecode3 = SWIG_AsVal_int(obj2, &val3);
31827 if (!SWIG_IsOK(ecode3)) {
31828 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31829 }
31830 arg3 = static_cast< int >(val3);
31831 {
31832 PyThreadState* __tstate = wxPyBeginAllowThreads();
31833 (arg1)->SetVirtualSize(arg2,arg3);
31834 wxPyEndAllowThreads(__tstate);
31835 if (PyErr_Occurred()) SWIG_fail;
31836 }
31837 resultobj = SWIG_Py_Void();
31838 return resultobj;
31839 fail:
31840 return NULL;
31841 }
31842
31843
31844 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31845 PyObject *resultobj = 0;
31846 wxWindow *arg1 = (wxWindow *) 0 ;
31847 wxSize result;
31848 void *argp1 = 0 ;
31849 int res1 = 0 ;
31850 PyObject *swig_obj[1] ;
31851
31852 if (!args) SWIG_fail;
31853 swig_obj[0] = args;
31854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31855 if (!SWIG_IsOK(res1)) {
31856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31857 }
31858 arg1 = reinterpret_cast< wxWindow * >(argp1);
31859 {
31860 PyThreadState* __tstate = wxPyBeginAllowThreads();
31861 result = ((wxWindow const *)arg1)->GetVirtualSize();
31862 wxPyEndAllowThreads(__tstate);
31863 if (PyErr_Occurred()) SWIG_fail;
31864 }
31865 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31866 return resultobj;
31867 fail:
31868 return NULL;
31869 }
31870
31871
31872 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31873 PyObject *resultobj = 0;
31874 wxWindow *arg1 = (wxWindow *) 0 ;
31875 int *arg2 = (int *) 0 ;
31876 int *arg3 = (int *) 0 ;
31877 void *argp1 = 0 ;
31878 int res1 = 0 ;
31879 int temp2 ;
31880 int res2 = SWIG_TMPOBJ ;
31881 int temp3 ;
31882 int res3 = SWIG_TMPOBJ ;
31883 PyObject *swig_obj[1] ;
31884
31885 arg2 = &temp2;
31886 arg3 = &temp3;
31887 if (!args) SWIG_fail;
31888 swig_obj[0] = args;
31889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31890 if (!SWIG_IsOK(res1)) {
31891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31892 }
31893 arg1 = reinterpret_cast< wxWindow * >(argp1);
31894 {
31895 PyThreadState* __tstate = wxPyBeginAllowThreads();
31896 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31897 wxPyEndAllowThreads(__tstate);
31898 if (PyErr_Occurred()) SWIG_fail;
31899 }
31900 resultobj = SWIG_Py_Void();
31901 if (SWIG_IsTmpObj(res2)) {
31902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31903 } else {
31904 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31906 }
31907 if (SWIG_IsTmpObj(res3)) {
31908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31909 } else {
31910 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31912 }
31913 return resultobj;
31914 fail:
31915 return NULL;
31916 }
31917
31918
31919 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31920 PyObject *resultobj = 0;
31921 wxWindow *arg1 = (wxWindow *) 0 ;
31922 wxSize result;
31923 void *argp1 = 0 ;
31924 int res1 = 0 ;
31925 PyObject *swig_obj[1] ;
31926
31927 if (!args) SWIG_fail;
31928 swig_obj[0] = args;
31929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31930 if (!SWIG_IsOK(res1)) {
31931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31932 }
31933 arg1 = reinterpret_cast< wxWindow * >(argp1);
31934 {
31935 PyThreadState* __tstate = wxPyBeginAllowThreads();
31936 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
31937 wxPyEndAllowThreads(__tstate);
31938 if (PyErr_Occurred()) SWIG_fail;
31939 }
31940 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31941 return resultobj;
31942 fail:
31943 return NULL;
31944 }
31945
31946
31947 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31948 PyObject *resultobj = 0;
31949 wxWindow *arg1 = (wxWindow *) 0 ;
31950 bool arg2 = (bool) true ;
31951 bool result;
31952 void *argp1 = 0 ;
31953 int res1 = 0 ;
31954 bool val2 ;
31955 int ecode2 = 0 ;
31956 PyObject * obj0 = 0 ;
31957 PyObject * obj1 = 0 ;
31958 char * kwnames[] = {
31959 (char *) "self",(char *) "show", NULL
31960 };
31961
31962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
31963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31964 if (!SWIG_IsOK(res1)) {
31965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
31966 }
31967 arg1 = reinterpret_cast< wxWindow * >(argp1);
31968 if (obj1) {
31969 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31970 if (!SWIG_IsOK(ecode2)) {
31971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
31972 }
31973 arg2 = static_cast< bool >(val2);
31974 }
31975 {
31976 PyThreadState* __tstate = wxPyBeginAllowThreads();
31977 result = (bool)(arg1)->Show(arg2);
31978 wxPyEndAllowThreads(__tstate);
31979 if (PyErr_Occurred()) SWIG_fail;
31980 }
31981 {
31982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31983 }
31984 return resultobj;
31985 fail:
31986 return NULL;
31987 }
31988
31989
31990 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31991 PyObject *resultobj = 0;
31992 wxWindow *arg1 = (wxWindow *) 0 ;
31993 bool result;
31994 void *argp1 = 0 ;
31995 int res1 = 0 ;
31996 PyObject *swig_obj[1] ;
31997
31998 if (!args) SWIG_fail;
31999 swig_obj[0] = args;
32000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32001 if (!SWIG_IsOK(res1)) {
32002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32003 }
32004 arg1 = reinterpret_cast< wxWindow * >(argp1);
32005 {
32006 PyThreadState* __tstate = wxPyBeginAllowThreads();
32007 result = (bool)(arg1)->Hide();
32008 wxPyEndAllowThreads(__tstate);
32009 if (PyErr_Occurred()) SWIG_fail;
32010 }
32011 {
32012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32013 }
32014 return resultobj;
32015 fail:
32016 return NULL;
32017 }
32018
32019
32020 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32021 PyObject *resultobj = 0;
32022 wxWindow *arg1 = (wxWindow *) 0 ;
32023 bool arg2 = (bool) true ;
32024 bool result;
32025 void *argp1 = 0 ;
32026 int res1 = 0 ;
32027 bool val2 ;
32028 int ecode2 = 0 ;
32029 PyObject * obj0 = 0 ;
32030 PyObject * obj1 = 0 ;
32031 char * kwnames[] = {
32032 (char *) "self",(char *) "enable", NULL
32033 };
32034
32035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32037 if (!SWIG_IsOK(res1)) {
32038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32039 }
32040 arg1 = reinterpret_cast< wxWindow * >(argp1);
32041 if (obj1) {
32042 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32043 if (!SWIG_IsOK(ecode2)) {
32044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32045 }
32046 arg2 = static_cast< bool >(val2);
32047 }
32048 {
32049 PyThreadState* __tstate = wxPyBeginAllowThreads();
32050 result = (bool)(arg1)->Enable(arg2);
32051 wxPyEndAllowThreads(__tstate);
32052 if (PyErr_Occurred()) SWIG_fail;
32053 }
32054 {
32055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32056 }
32057 return resultobj;
32058 fail:
32059 return NULL;
32060 }
32061
32062
32063 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32064 PyObject *resultobj = 0;
32065 wxWindow *arg1 = (wxWindow *) 0 ;
32066 bool result;
32067 void *argp1 = 0 ;
32068 int res1 = 0 ;
32069 PyObject *swig_obj[1] ;
32070
32071 if (!args) SWIG_fail;
32072 swig_obj[0] = args;
32073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32074 if (!SWIG_IsOK(res1)) {
32075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32076 }
32077 arg1 = reinterpret_cast< wxWindow * >(argp1);
32078 {
32079 PyThreadState* __tstate = wxPyBeginAllowThreads();
32080 result = (bool)(arg1)->Disable();
32081 wxPyEndAllowThreads(__tstate);
32082 if (PyErr_Occurred()) SWIG_fail;
32083 }
32084 {
32085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32086 }
32087 return resultobj;
32088 fail:
32089 return NULL;
32090 }
32091
32092
32093 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32094 PyObject *resultobj = 0;
32095 wxWindow *arg1 = (wxWindow *) 0 ;
32096 bool result;
32097 void *argp1 = 0 ;
32098 int res1 = 0 ;
32099 PyObject *swig_obj[1] ;
32100
32101 if (!args) SWIG_fail;
32102 swig_obj[0] = args;
32103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32104 if (!SWIG_IsOK(res1)) {
32105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32106 }
32107 arg1 = reinterpret_cast< wxWindow * >(argp1);
32108 {
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 result = (bool)((wxWindow const *)arg1)->IsShown();
32111 wxPyEndAllowThreads(__tstate);
32112 if (PyErr_Occurred()) SWIG_fail;
32113 }
32114 {
32115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32116 }
32117 return resultobj;
32118 fail:
32119 return NULL;
32120 }
32121
32122
32123 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32124 PyObject *resultobj = 0;
32125 wxWindow *arg1 = (wxWindow *) 0 ;
32126 bool result;
32127 void *argp1 = 0 ;
32128 int res1 = 0 ;
32129 PyObject *swig_obj[1] ;
32130
32131 if (!args) SWIG_fail;
32132 swig_obj[0] = args;
32133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32134 if (!SWIG_IsOK(res1)) {
32135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32136 }
32137 arg1 = reinterpret_cast< wxWindow * >(argp1);
32138 {
32139 PyThreadState* __tstate = wxPyBeginAllowThreads();
32140 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32141 wxPyEndAllowThreads(__tstate);
32142 if (PyErr_Occurred()) SWIG_fail;
32143 }
32144 {
32145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32146 }
32147 return resultobj;
32148 fail:
32149 return NULL;
32150 }
32151
32152
32153 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32154 PyObject *resultobj = 0;
32155 wxWindow *arg1 = (wxWindow *) 0 ;
32156 long arg2 ;
32157 void *argp1 = 0 ;
32158 int res1 = 0 ;
32159 long val2 ;
32160 int ecode2 = 0 ;
32161 PyObject * obj0 = 0 ;
32162 PyObject * obj1 = 0 ;
32163 char * kwnames[] = {
32164 (char *) "self",(char *) "style", NULL
32165 };
32166
32167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32169 if (!SWIG_IsOK(res1)) {
32170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32171 }
32172 arg1 = reinterpret_cast< wxWindow * >(argp1);
32173 ecode2 = SWIG_AsVal_long(obj1, &val2);
32174 if (!SWIG_IsOK(ecode2)) {
32175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32176 }
32177 arg2 = static_cast< long >(val2);
32178 {
32179 PyThreadState* __tstate = wxPyBeginAllowThreads();
32180 (arg1)->SetWindowStyleFlag(arg2);
32181 wxPyEndAllowThreads(__tstate);
32182 if (PyErr_Occurred()) SWIG_fail;
32183 }
32184 resultobj = SWIG_Py_Void();
32185 return resultobj;
32186 fail:
32187 return NULL;
32188 }
32189
32190
32191 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32192 PyObject *resultobj = 0;
32193 wxWindow *arg1 = (wxWindow *) 0 ;
32194 long result;
32195 void *argp1 = 0 ;
32196 int res1 = 0 ;
32197 PyObject *swig_obj[1] ;
32198
32199 if (!args) SWIG_fail;
32200 swig_obj[0] = args;
32201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32202 if (!SWIG_IsOK(res1)) {
32203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32204 }
32205 arg1 = reinterpret_cast< wxWindow * >(argp1);
32206 {
32207 PyThreadState* __tstate = wxPyBeginAllowThreads();
32208 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32209 wxPyEndAllowThreads(__tstate);
32210 if (PyErr_Occurred()) SWIG_fail;
32211 }
32212 resultobj = SWIG_From_long(static_cast< long >(result));
32213 return resultobj;
32214 fail:
32215 return NULL;
32216 }
32217
32218
32219 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32220 PyObject *resultobj = 0;
32221 wxWindow *arg1 = (wxWindow *) 0 ;
32222 int arg2 ;
32223 bool result;
32224 void *argp1 = 0 ;
32225 int res1 = 0 ;
32226 int val2 ;
32227 int ecode2 = 0 ;
32228 PyObject * obj0 = 0 ;
32229 PyObject * obj1 = 0 ;
32230 char * kwnames[] = {
32231 (char *) "self",(char *) "flag", NULL
32232 };
32233
32234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32236 if (!SWIG_IsOK(res1)) {
32237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32238 }
32239 arg1 = reinterpret_cast< wxWindow * >(argp1);
32240 ecode2 = SWIG_AsVal_int(obj1, &val2);
32241 if (!SWIG_IsOK(ecode2)) {
32242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32243 }
32244 arg2 = static_cast< int >(val2);
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 {
32252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32253 }
32254 return resultobj;
32255 fail:
32256 return NULL;
32257 }
32258
32259
32260 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32261 PyObject *resultobj = 0;
32262 wxWindow *arg1 = (wxWindow *) 0 ;
32263 bool result;
32264 void *argp1 = 0 ;
32265 int res1 = 0 ;
32266 PyObject *swig_obj[1] ;
32267
32268 if (!args) SWIG_fail;
32269 swig_obj[0] = args;
32270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32271 if (!SWIG_IsOK(res1)) {
32272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32273 }
32274 arg1 = reinterpret_cast< wxWindow * >(argp1);
32275 {
32276 PyThreadState* __tstate = wxPyBeginAllowThreads();
32277 result = (bool)((wxWindow const *)arg1)->IsRetained();
32278 wxPyEndAllowThreads(__tstate);
32279 if (PyErr_Occurred()) SWIG_fail;
32280 }
32281 {
32282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32283 }
32284 return resultobj;
32285 fail:
32286 return NULL;
32287 }
32288
32289
32290 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32291 PyObject *resultobj = 0;
32292 wxWindow *arg1 = (wxWindow *) 0 ;
32293 long arg2 ;
32294 void *argp1 = 0 ;
32295 int res1 = 0 ;
32296 long val2 ;
32297 int ecode2 = 0 ;
32298 PyObject * obj0 = 0 ;
32299 PyObject * obj1 = 0 ;
32300 char * kwnames[] = {
32301 (char *) "self",(char *) "exStyle", NULL
32302 };
32303
32304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32306 if (!SWIG_IsOK(res1)) {
32307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32308 }
32309 arg1 = reinterpret_cast< wxWindow * >(argp1);
32310 ecode2 = SWIG_AsVal_long(obj1, &val2);
32311 if (!SWIG_IsOK(ecode2)) {
32312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32313 }
32314 arg2 = static_cast< long >(val2);
32315 {
32316 PyThreadState* __tstate = wxPyBeginAllowThreads();
32317 (arg1)->SetExtraStyle(arg2);
32318 wxPyEndAllowThreads(__tstate);
32319 if (PyErr_Occurred()) SWIG_fail;
32320 }
32321 resultobj = SWIG_Py_Void();
32322 return resultobj;
32323 fail:
32324 return NULL;
32325 }
32326
32327
32328 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32329 PyObject *resultobj = 0;
32330 wxWindow *arg1 = (wxWindow *) 0 ;
32331 long result;
32332 void *argp1 = 0 ;
32333 int res1 = 0 ;
32334 PyObject *swig_obj[1] ;
32335
32336 if (!args) SWIG_fail;
32337 swig_obj[0] = args;
32338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32339 if (!SWIG_IsOK(res1)) {
32340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32341 }
32342 arg1 = reinterpret_cast< wxWindow * >(argp1);
32343 {
32344 PyThreadState* __tstate = wxPyBeginAllowThreads();
32345 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32346 wxPyEndAllowThreads(__tstate);
32347 if (PyErr_Occurred()) SWIG_fail;
32348 }
32349 resultobj = SWIG_From_long(static_cast< long >(result));
32350 return resultobj;
32351 fail:
32352 return NULL;
32353 }
32354
32355
32356 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32357 PyObject *resultobj = 0;
32358 wxWindow *arg1 = (wxWindow *) 0 ;
32359 bool arg2 = (bool) true ;
32360 void *argp1 = 0 ;
32361 int res1 = 0 ;
32362 bool val2 ;
32363 int ecode2 = 0 ;
32364 PyObject * obj0 = 0 ;
32365 PyObject * obj1 = 0 ;
32366 char * kwnames[] = {
32367 (char *) "self",(char *) "modal", NULL
32368 };
32369
32370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32372 if (!SWIG_IsOK(res1)) {
32373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32374 }
32375 arg1 = reinterpret_cast< wxWindow * >(argp1);
32376 if (obj1) {
32377 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32378 if (!SWIG_IsOK(ecode2)) {
32379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32380 }
32381 arg2 = static_cast< bool >(val2);
32382 }
32383 {
32384 PyThreadState* __tstate = wxPyBeginAllowThreads();
32385 (arg1)->MakeModal(arg2);
32386 wxPyEndAllowThreads(__tstate);
32387 if (PyErr_Occurred()) SWIG_fail;
32388 }
32389 resultobj = SWIG_Py_Void();
32390 return resultobj;
32391 fail:
32392 return NULL;
32393 }
32394
32395
32396 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32397 PyObject *resultobj = 0;
32398 wxWindow *arg1 = (wxWindow *) 0 ;
32399 bool arg2 ;
32400 void *argp1 = 0 ;
32401 int res1 = 0 ;
32402 bool val2 ;
32403 int ecode2 = 0 ;
32404 PyObject * obj0 = 0 ;
32405 PyObject * obj1 = 0 ;
32406 char * kwnames[] = {
32407 (char *) "self",(char *) "enableTheme", NULL
32408 };
32409
32410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32412 if (!SWIG_IsOK(res1)) {
32413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32414 }
32415 arg1 = reinterpret_cast< wxWindow * >(argp1);
32416 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32417 if (!SWIG_IsOK(ecode2)) {
32418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32419 }
32420 arg2 = static_cast< bool >(val2);
32421 {
32422 PyThreadState* __tstate = wxPyBeginAllowThreads();
32423 (arg1)->SetThemeEnabled(arg2);
32424 wxPyEndAllowThreads(__tstate);
32425 if (PyErr_Occurred()) SWIG_fail;
32426 }
32427 resultobj = SWIG_Py_Void();
32428 return resultobj;
32429 fail:
32430 return NULL;
32431 }
32432
32433
32434 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32435 PyObject *resultobj = 0;
32436 wxWindow *arg1 = (wxWindow *) 0 ;
32437 bool result;
32438 void *argp1 = 0 ;
32439 int res1 = 0 ;
32440 PyObject *swig_obj[1] ;
32441
32442 if (!args) SWIG_fail;
32443 swig_obj[0] = args;
32444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32445 if (!SWIG_IsOK(res1)) {
32446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32447 }
32448 arg1 = reinterpret_cast< wxWindow * >(argp1);
32449 {
32450 PyThreadState* __tstate = wxPyBeginAllowThreads();
32451 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32452 wxPyEndAllowThreads(__tstate);
32453 if (PyErr_Occurred()) SWIG_fail;
32454 }
32455 {
32456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32457 }
32458 return resultobj;
32459 fail:
32460 return NULL;
32461 }
32462
32463
32464 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32465 PyObject *resultobj = 0;
32466 wxWindow *arg1 = (wxWindow *) 0 ;
32467 void *argp1 = 0 ;
32468 int res1 = 0 ;
32469 PyObject *swig_obj[1] ;
32470
32471 if (!args) SWIG_fail;
32472 swig_obj[0] = args;
32473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32474 if (!SWIG_IsOK(res1)) {
32475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32476 }
32477 arg1 = reinterpret_cast< wxWindow * >(argp1);
32478 {
32479 PyThreadState* __tstate = wxPyBeginAllowThreads();
32480 (arg1)->SetFocus();
32481 wxPyEndAllowThreads(__tstate);
32482 if (PyErr_Occurred()) SWIG_fail;
32483 }
32484 resultobj = SWIG_Py_Void();
32485 return resultobj;
32486 fail:
32487 return NULL;
32488 }
32489
32490
32491 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32492 PyObject *resultobj = 0;
32493 wxWindow *arg1 = (wxWindow *) 0 ;
32494 void *argp1 = 0 ;
32495 int res1 = 0 ;
32496 PyObject *swig_obj[1] ;
32497
32498 if (!args) SWIG_fail;
32499 swig_obj[0] = args;
32500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32501 if (!SWIG_IsOK(res1)) {
32502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32503 }
32504 arg1 = reinterpret_cast< wxWindow * >(argp1);
32505 {
32506 PyThreadState* __tstate = wxPyBeginAllowThreads();
32507 (arg1)->SetFocusFromKbd();
32508 wxPyEndAllowThreads(__tstate);
32509 if (PyErr_Occurred()) SWIG_fail;
32510 }
32511 resultobj = SWIG_Py_Void();
32512 return resultobj;
32513 fail:
32514 return NULL;
32515 }
32516
32517
32518 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32519 PyObject *resultobj = 0;
32520 wxWindow *result = 0 ;
32521
32522 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32523 {
32524 if (!wxPyCheckForApp()) SWIG_fail;
32525 PyThreadState* __tstate = wxPyBeginAllowThreads();
32526 result = (wxWindow *)wxWindow::FindFocus();
32527 wxPyEndAllowThreads(__tstate);
32528 if (PyErr_Occurred()) SWIG_fail;
32529 }
32530 {
32531 resultobj = wxPyMake_wxObject(result, 0);
32532 }
32533 return resultobj;
32534 fail:
32535 return NULL;
32536 }
32537
32538
32539 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32540 PyObject *resultobj = 0;
32541 wxWindow *arg1 = (wxWindow *) 0 ;
32542 bool result;
32543 void *argp1 = 0 ;
32544 int res1 = 0 ;
32545 PyObject *swig_obj[1] ;
32546
32547 if (!args) SWIG_fail;
32548 swig_obj[0] = args;
32549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32550 if (!SWIG_IsOK(res1)) {
32551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32552 }
32553 arg1 = reinterpret_cast< wxWindow * >(argp1);
32554 {
32555 PyThreadState* __tstate = wxPyBeginAllowThreads();
32556 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32557 wxPyEndAllowThreads(__tstate);
32558 if (PyErr_Occurred()) SWIG_fail;
32559 }
32560 {
32561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32562 }
32563 return resultobj;
32564 fail:
32565 return NULL;
32566 }
32567
32568
32569 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32570 PyObject *resultobj = 0;
32571 wxWindow *arg1 = (wxWindow *) 0 ;
32572 bool result;
32573 void *argp1 = 0 ;
32574 int res1 = 0 ;
32575 PyObject *swig_obj[1] ;
32576
32577 if (!args) SWIG_fail;
32578 swig_obj[0] = args;
32579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32580 if (!SWIG_IsOK(res1)) {
32581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32582 }
32583 arg1 = reinterpret_cast< wxWindow * >(argp1);
32584 {
32585 PyThreadState* __tstate = wxPyBeginAllowThreads();
32586 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32587 wxPyEndAllowThreads(__tstate);
32588 if (PyErr_Occurred()) SWIG_fail;
32589 }
32590 {
32591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32592 }
32593 return resultobj;
32594 fail:
32595 return NULL;
32596 }
32597
32598
32599 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32600 PyObject *resultobj = 0;
32601 wxWindow *arg1 = (wxWindow *) 0 ;
32602 wxWindow *result = 0 ;
32603 void *argp1 = 0 ;
32604 int res1 = 0 ;
32605 PyObject *swig_obj[1] ;
32606
32607 if (!args) SWIG_fail;
32608 swig_obj[0] = args;
32609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32610 if (!SWIG_IsOK(res1)) {
32611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32612 }
32613 arg1 = reinterpret_cast< wxWindow * >(argp1);
32614 {
32615 PyThreadState* __tstate = wxPyBeginAllowThreads();
32616 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32617 wxPyEndAllowThreads(__tstate);
32618 if (PyErr_Occurred()) SWIG_fail;
32619 }
32620 {
32621 resultobj = wxPyMake_wxObject(result, 0);
32622 }
32623 return resultobj;
32624 fail:
32625 return NULL;
32626 }
32627
32628
32629 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32630 PyObject *resultobj = 0;
32631 wxWindow *arg1 = (wxWindow *) 0 ;
32632 wxWindow *arg2 = (wxWindow *) 0 ;
32633 wxWindow *result = 0 ;
32634 void *argp1 = 0 ;
32635 int res1 = 0 ;
32636 void *argp2 = 0 ;
32637 int res2 = 0 ;
32638 PyObject * obj0 = 0 ;
32639 PyObject * obj1 = 0 ;
32640 char * kwnames[] = {
32641 (char *) "self",(char *) "child", NULL
32642 };
32643
32644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32646 if (!SWIG_IsOK(res1)) {
32647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32648 }
32649 arg1 = reinterpret_cast< wxWindow * >(argp1);
32650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32651 if (!SWIG_IsOK(res2)) {
32652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32653 }
32654 arg2 = reinterpret_cast< wxWindow * >(argp2);
32655 {
32656 PyThreadState* __tstate = wxPyBeginAllowThreads();
32657 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32658 wxPyEndAllowThreads(__tstate);
32659 if (PyErr_Occurred()) SWIG_fail;
32660 }
32661 {
32662 resultobj = wxPyMake_wxObject(result, 0);
32663 }
32664 return resultobj;
32665 fail:
32666 return NULL;
32667 }
32668
32669
32670 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32671 PyObject *resultobj = 0;
32672 wxWindow *arg1 = (wxWindow *) 0 ;
32673 wxWindow *arg2 = (wxWindow *) 0 ;
32674 void *argp1 = 0 ;
32675 int res1 = 0 ;
32676 void *argp2 = 0 ;
32677 int res2 = 0 ;
32678 PyObject * obj0 = 0 ;
32679 PyObject * obj1 = 0 ;
32680 char * kwnames[] = {
32681 (char *) "self",(char *) "win", NULL
32682 };
32683
32684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32686 if (!SWIG_IsOK(res1)) {
32687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32688 }
32689 arg1 = reinterpret_cast< wxWindow * >(argp1);
32690 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32691 if (!SWIG_IsOK(res2)) {
32692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32693 }
32694 arg2 = reinterpret_cast< wxWindow * >(argp2);
32695 {
32696 PyThreadState* __tstate = wxPyBeginAllowThreads();
32697 (arg1)->SetTmpDefaultItem(arg2);
32698 wxPyEndAllowThreads(__tstate);
32699 if (PyErr_Occurred()) SWIG_fail;
32700 }
32701 resultobj = SWIG_Py_Void();
32702 return resultobj;
32703 fail:
32704 return NULL;
32705 }
32706
32707
32708 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32709 PyObject *resultobj = 0;
32710 wxWindow *arg1 = (wxWindow *) 0 ;
32711 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32712 bool result;
32713 void *argp1 = 0 ;
32714 int res1 = 0 ;
32715 int val2 ;
32716 int ecode2 = 0 ;
32717 PyObject * obj0 = 0 ;
32718 PyObject * obj1 = 0 ;
32719 char * kwnames[] = {
32720 (char *) "self",(char *) "flags", NULL
32721 };
32722
32723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32725 if (!SWIG_IsOK(res1)) {
32726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32727 }
32728 arg1 = reinterpret_cast< wxWindow * >(argp1);
32729 if (obj1) {
32730 ecode2 = SWIG_AsVal_int(obj1, &val2);
32731 if (!SWIG_IsOK(ecode2)) {
32732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32733 }
32734 arg2 = static_cast< int >(val2);
32735 }
32736 {
32737 PyThreadState* __tstate = wxPyBeginAllowThreads();
32738 result = (bool)(arg1)->Navigate(arg2);
32739 wxPyEndAllowThreads(__tstate);
32740 if (PyErr_Occurred()) SWIG_fail;
32741 }
32742 {
32743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32744 }
32745 return resultobj;
32746 fail:
32747 return NULL;
32748 }
32749
32750
32751 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32752 PyObject *resultobj = 0;
32753 wxWindow *arg1 = (wxWindow *) 0 ;
32754 wxWindow *arg2 = (wxWindow *) 0 ;
32755 void *argp1 = 0 ;
32756 int res1 = 0 ;
32757 void *argp2 = 0 ;
32758 int res2 = 0 ;
32759 PyObject * obj0 = 0 ;
32760 PyObject * obj1 = 0 ;
32761 char * kwnames[] = {
32762 (char *) "self",(char *) "win", NULL
32763 };
32764
32765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32767 if (!SWIG_IsOK(res1)) {
32768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32769 }
32770 arg1 = reinterpret_cast< wxWindow * >(argp1);
32771 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32772 if (!SWIG_IsOK(res2)) {
32773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32774 }
32775 arg2 = reinterpret_cast< wxWindow * >(argp2);
32776 {
32777 PyThreadState* __tstate = wxPyBeginAllowThreads();
32778 (arg1)->MoveAfterInTabOrder(arg2);
32779 wxPyEndAllowThreads(__tstate);
32780 if (PyErr_Occurred()) SWIG_fail;
32781 }
32782 resultobj = SWIG_Py_Void();
32783 return resultobj;
32784 fail:
32785 return NULL;
32786 }
32787
32788
32789 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32790 PyObject *resultobj = 0;
32791 wxWindow *arg1 = (wxWindow *) 0 ;
32792 wxWindow *arg2 = (wxWindow *) 0 ;
32793 void *argp1 = 0 ;
32794 int res1 = 0 ;
32795 void *argp2 = 0 ;
32796 int res2 = 0 ;
32797 PyObject * obj0 = 0 ;
32798 PyObject * obj1 = 0 ;
32799 char * kwnames[] = {
32800 (char *) "self",(char *) "win", NULL
32801 };
32802
32803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32805 if (!SWIG_IsOK(res1)) {
32806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32807 }
32808 arg1 = reinterpret_cast< wxWindow * >(argp1);
32809 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32810 if (!SWIG_IsOK(res2)) {
32811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32812 }
32813 arg2 = reinterpret_cast< wxWindow * >(argp2);
32814 {
32815 PyThreadState* __tstate = wxPyBeginAllowThreads();
32816 (arg1)->MoveBeforeInTabOrder(arg2);
32817 wxPyEndAllowThreads(__tstate);
32818 if (PyErr_Occurred()) SWIG_fail;
32819 }
32820 resultobj = SWIG_Py_Void();
32821 return resultobj;
32822 fail:
32823 return NULL;
32824 }
32825
32826
32827 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32828 PyObject *resultobj = 0;
32829 wxWindow *arg1 = (wxWindow *) 0 ;
32830 PyObject *result = 0 ;
32831 void *argp1 = 0 ;
32832 int res1 = 0 ;
32833 PyObject *swig_obj[1] ;
32834
32835 if (!args) SWIG_fail;
32836 swig_obj[0] = args;
32837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32838 if (!SWIG_IsOK(res1)) {
32839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32840 }
32841 arg1 = reinterpret_cast< wxWindow * >(argp1);
32842 {
32843 PyThreadState* __tstate = wxPyBeginAllowThreads();
32844 result = (PyObject *)wxWindow_GetChildren(arg1);
32845 wxPyEndAllowThreads(__tstate);
32846 if (PyErr_Occurred()) SWIG_fail;
32847 }
32848 resultobj = result;
32849 return resultobj;
32850 fail:
32851 return NULL;
32852 }
32853
32854
32855 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32856 PyObject *resultobj = 0;
32857 wxWindow *arg1 = (wxWindow *) 0 ;
32858 wxWindow *result = 0 ;
32859 void *argp1 = 0 ;
32860 int res1 = 0 ;
32861 PyObject *swig_obj[1] ;
32862
32863 if (!args) SWIG_fail;
32864 swig_obj[0] = args;
32865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32866 if (!SWIG_IsOK(res1)) {
32867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32868 }
32869 arg1 = reinterpret_cast< wxWindow * >(argp1);
32870 {
32871 PyThreadState* __tstate = wxPyBeginAllowThreads();
32872 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32873 wxPyEndAllowThreads(__tstate);
32874 if (PyErr_Occurred()) SWIG_fail;
32875 }
32876 {
32877 resultobj = wxPyMake_wxObject(result, 0);
32878 }
32879 return resultobj;
32880 fail:
32881 return NULL;
32882 }
32883
32884
32885 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32886 PyObject *resultobj = 0;
32887 wxWindow *arg1 = (wxWindow *) 0 ;
32888 wxWindow *result = 0 ;
32889 void *argp1 = 0 ;
32890 int res1 = 0 ;
32891 PyObject *swig_obj[1] ;
32892
32893 if (!args) SWIG_fail;
32894 swig_obj[0] = args;
32895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32896 if (!SWIG_IsOK(res1)) {
32897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32898 }
32899 arg1 = reinterpret_cast< wxWindow * >(argp1);
32900 {
32901 PyThreadState* __tstate = wxPyBeginAllowThreads();
32902 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32903 wxPyEndAllowThreads(__tstate);
32904 if (PyErr_Occurred()) SWIG_fail;
32905 }
32906 {
32907 resultobj = wxPyMake_wxObject(result, 0);
32908 }
32909 return resultobj;
32910 fail:
32911 return NULL;
32912 }
32913
32914
32915 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32916 PyObject *resultobj = 0;
32917 wxWindow *arg1 = (wxWindow *) 0 ;
32918 bool result;
32919 void *argp1 = 0 ;
32920 int res1 = 0 ;
32921 PyObject *swig_obj[1] ;
32922
32923 if (!args) SWIG_fail;
32924 swig_obj[0] = args;
32925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32926 if (!SWIG_IsOK(res1)) {
32927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
32928 }
32929 arg1 = reinterpret_cast< wxWindow * >(argp1);
32930 {
32931 PyThreadState* __tstate = wxPyBeginAllowThreads();
32932 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
32933 wxPyEndAllowThreads(__tstate);
32934 if (PyErr_Occurred()) SWIG_fail;
32935 }
32936 {
32937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32938 }
32939 return resultobj;
32940 fail:
32941 return NULL;
32942 }
32943
32944
32945 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32946 PyObject *resultobj = 0;
32947 wxWindow *arg1 = (wxWindow *) 0 ;
32948 wxWindow *arg2 = (wxWindow *) 0 ;
32949 bool result;
32950 void *argp1 = 0 ;
32951 int res1 = 0 ;
32952 void *argp2 = 0 ;
32953 int res2 = 0 ;
32954 PyObject * obj0 = 0 ;
32955 PyObject * obj1 = 0 ;
32956 char * kwnames[] = {
32957 (char *) "self",(char *) "newParent", NULL
32958 };
32959
32960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
32961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32962 if (!SWIG_IsOK(res1)) {
32963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
32964 }
32965 arg1 = reinterpret_cast< wxWindow * >(argp1);
32966 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32967 if (!SWIG_IsOK(res2)) {
32968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
32969 }
32970 arg2 = reinterpret_cast< wxWindow * >(argp2);
32971 {
32972 PyThreadState* __tstate = wxPyBeginAllowThreads();
32973 result = (bool)(arg1)->Reparent(arg2);
32974 wxPyEndAllowThreads(__tstate);
32975 if (PyErr_Occurred()) SWIG_fail;
32976 }
32977 {
32978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32979 }
32980 return resultobj;
32981 fail:
32982 return NULL;
32983 }
32984
32985
32986 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32987 PyObject *resultobj = 0;
32988 wxWindow *arg1 = (wxWindow *) 0 ;
32989 wxWindow *arg2 = (wxWindow *) 0 ;
32990 void *argp1 = 0 ;
32991 int res1 = 0 ;
32992 void *argp2 = 0 ;
32993 int res2 = 0 ;
32994 PyObject * obj0 = 0 ;
32995 PyObject * obj1 = 0 ;
32996 char * kwnames[] = {
32997 (char *) "self",(char *) "child", NULL
32998 };
32999
33000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33002 if (!SWIG_IsOK(res1)) {
33003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33004 }
33005 arg1 = reinterpret_cast< wxWindow * >(argp1);
33006 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33007 if (!SWIG_IsOK(res2)) {
33008 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33009 }
33010 arg2 = reinterpret_cast< wxWindow * >(argp2);
33011 {
33012 PyThreadState* __tstate = wxPyBeginAllowThreads();
33013 (arg1)->AddChild(arg2);
33014 wxPyEndAllowThreads(__tstate);
33015 if (PyErr_Occurred()) SWIG_fail;
33016 }
33017 resultobj = SWIG_Py_Void();
33018 return resultobj;
33019 fail:
33020 return NULL;
33021 }
33022
33023
33024 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33025 PyObject *resultobj = 0;
33026 wxWindow *arg1 = (wxWindow *) 0 ;
33027 wxWindow *arg2 = (wxWindow *) 0 ;
33028 void *argp1 = 0 ;
33029 int res1 = 0 ;
33030 void *argp2 = 0 ;
33031 int res2 = 0 ;
33032 PyObject * obj0 = 0 ;
33033 PyObject * obj1 = 0 ;
33034 char * kwnames[] = {
33035 (char *) "self",(char *) "child", NULL
33036 };
33037
33038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33040 if (!SWIG_IsOK(res1)) {
33041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33042 }
33043 arg1 = reinterpret_cast< wxWindow * >(argp1);
33044 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33045 if (!SWIG_IsOK(res2)) {
33046 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33047 }
33048 arg2 = reinterpret_cast< wxWindow * >(argp2);
33049 {
33050 PyThreadState* __tstate = wxPyBeginAllowThreads();
33051 (arg1)->RemoveChild(arg2);
33052 wxPyEndAllowThreads(__tstate);
33053 if (PyErr_Occurred()) SWIG_fail;
33054 }
33055 resultobj = SWIG_Py_Void();
33056 return resultobj;
33057 fail:
33058 return NULL;
33059 }
33060
33061
33062 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33063 PyObject *resultobj = 0;
33064 wxWindow *arg1 = (wxWindow *) 0 ;
33065 long arg2 ;
33066 wxWindow *result = 0 ;
33067 void *argp1 = 0 ;
33068 int res1 = 0 ;
33069 long val2 ;
33070 int ecode2 = 0 ;
33071 PyObject * obj0 = 0 ;
33072 PyObject * obj1 = 0 ;
33073 char * kwnames[] = {
33074 (char *) "self",(char *) "winid", NULL
33075 };
33076
33077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33079 if (!SWIG_IsOK(res1)) {
33080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33081 }
33082 arg1 = reinterpret_cast< wxWindow * >(argp1);
33083 ecode2 = SWIG_AsVal_long(obj1, &val2);
33084 if (!SWIG_IsOK(ecode2)) {
33085 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33086 }
33087 arg2 = static_cast< long >(val2);
33088 {
33089 PyThreadState* __tstate = wxPyBeginAllowThreads();
33090 result = (wxWindow *)(arg1)->FindWindow(arg2);
33091 wxPyEndAllowThreads(__tstate);
33092 if (PyErr_Occurred()) SWIG_fail;
33093 }
33094 {
33095 resultobj = wxPyMake_wxObject(result, 0);
33096 }
33097 return resultobj;
33098 fail:
33099 return NULL;
33100 }
33101
33102
33103 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33104 PyObject *resultobj = 0;
33105 wxWindow *arg1 = (wxWindow *) 0 ;
33106 wxString *arg2 = 0 ;
33107 wxWindow *result = 0 ;
33108 void *argp1 = 0 ;
33109 int res1 = 0 ;
33110 bool temp2 = false ;
33111 PyObject * obj0 = 0 ;
33112 PyObject * obj1 = 0 ;
33113 char * kwnames[] = {
33114 (char *) "self",(char *) "name", NULL
33115 };
33116
33117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33119 if (!SWIG_IsOK(res1)) {
33120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33121 }
33122 arg1 = reinterpret_cast< wxWindow * >(argp1);
33123 {
33124 arg2 = wxString_in_helper(obj1);
33125 if (arg2 == NULL) SWIG_fail;
33126 temp2 = true;
33127 }
33128 {
33129 PyThreadState* __tstate = wxPyBeginAllowThreads();
33130 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33131 wxPyEndAllowThreads(__tstate);
33132 if (PyErr_Occurred()) SWIG_fail;
33133 }
33134 {
33135 resultobj = wxPyMake_wxObject(result, 0);
33136 }
33137 {
33138 if (temp2)
33139 delete arg2;
33140 }
33141 return resultobj;
33142 fail:
33143 {
33144 if (temp2)
33145 delete arg2;
33146 }
33147 return NULL;
33148 }
33149
33150
33151 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33152 PyObject *resultobj = 0;
33153 wxWindow *arg1 = (wxWindow *) 0 ;
33154 wxEvtHandler *result = 0 ;
33155 void *argp1 = 0 ;
33156 int res1 = 0 ;
33157 PyObject *swig_obj[1] ;
33158
33159 if (!args) SWIG_fail;
33160 swig_obj[0] = args;
33161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33162 if (!SWIG_IsOK(res1)) {
33163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33164 }
33165 arg1 = reinterpret_cast< wxWindow * >(argp1);
33166 {
33167 PyThreadState* __tstate = wxPyBeginAllowThreads();
33168 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33169 wxPyEndAllowThreads(__tstate);
33170 if (PyErr_Occurred()) SWIG_fail;
33171 }
33172 {
33173 resultobj = wxPyMake_wxObject(result, 0);
33174 }
33175 return resultobj;
33176 fail:
33177 return NULL;
33178 }
33179
33180
33181 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33182 PyObject *resultobj = 0;
33183 wxWindow *arg1 = (wxWindow *) 0 ;
33184 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33185 void *argp1 = 0 ;
33186 int res1 = 0 ;
33187 void *argp2 = 0 ;
33188 int res2 = 0 ;
33189 PyObject * obj0 = 0 ;
33190 PyObject * obj1 = 0 ;
33191 char * kwnames[] = {
33192 (char *) "self",(char *) "handler", NULL
33193 };
33194
33195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33197 if (!SWIG_IsOK(res1)) {
33198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33199 }
33200 arg1 = reinterpret_cast< wxWindow * >(argp1);
33201 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33202 if (!SWIG_IsOK(res2)) {
33203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33204 }
33205 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33206 {
33207 PyThreadState* __tstate = wxPyBeginAllowThreads();
33208 (arg1)->SetEventHandler(arg2);
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 resultobj = SWIG_Py_Void();
33213 return resultobj;
33214 fail:
33215 return NULL;
33216 }
33217
33218
33219 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33220 PyObject *resultobj = 0;
33221 wxWindow *arg1 = (wxWindow *) 0 ;
33222 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33223 void *argp1 = 0 ;
33224 int res1 = 0 ;
33225 void *argp2 = 0 ;
33226 int res2 = 0 ;
33227 PyObject * obj0 = 0 ;
33228 PyObject * obj1 = 0 ;
33229 char * kwnames[] = {
33230 (char *) "self",(char *) "handler", NULL
33231 };
33232
33233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33235 if (!SWIG_IsOK(res1)) {
33236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33237 }
33238 arg1 = reinterpret_cast< wxWindow * >(argp1);
33239 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33240 if (!SWIG_IsOK(res2)) {
33241 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33242 }
33243 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33244 {
33245 PyThreadState* __tstate = wxPyBeginAllowThreads();
33246 (arg1)->PushEventHandler(arg2);
33247 wxPyEndAllowThreads(__tstate);
33248 if (PyErr_Occurred()) SWIG_fail;
33249 }
33250 resultobj = SWIG_Py_Void();
33251 return resultobj;
33252 fail:
33253 return NULL;
33254 }
33255
33256
33257 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33258 PyObject *resultobj = 0;
33259 wxWindow *arg1 = (wxWindow *) 0 ;
33260 bool arg2 = (bool) false ;
33261 wxEvtHandler *result = 0 ;
33262 void *argp1 = 0 ;
33263 int res1 = 0 ;
33264 bool val2 ;
33265 int ecode2 = 0 ;
33266 PyObject * obj0 = 0 ;
33267 PyObject * obj1 = 0 ;
33268 char * kwnames[] = {
33269 (char *) "self",(char *) "deleteHandler", NULL
33270 };
33271
33272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33274 if (!SWIG_IsOK(res1)) {
33275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33276 }
33277 arg1 = reinterpret_cast< wxWindow * >(argp1);
33278 if (obj1) {
33279 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33280 if (!SWIG_IsOK(ecode2)) {
33281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33282 }
33283 arg2 = static_cast< bool >(val2);
33284 }
33285 {
33286 PyThreadState* __tstate = wxPyBeginAllowThreads();
33287 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33288 wxPyEndAllowThreads(__tstate);
33289 if (PyErr_Occurred()) SWIG_fail;
33290 }
33291 {
33292 resultobj = wxPyMake_wxObject(result, 0);
33293 }
33294 return resultobj;
33295 fail:
33296 return NULL;
33297 }
33298
33299
33300 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33301 PyObject *resultobj = 0;
33302 wxWindow *arg1 = (wxWindow *) 0 ;
33303 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33304 bool result;
33305 void *argp1 = 0 ;
33306 int res1 = 0 ;
33307 void *argp2 = 0 ;
33308 int res2 = 0 ;
33309 PyObject * obj0 = 0 ;
33310 PyObject * obj1 = 0 ;
33311 char * kwnames[] = {
33312 (char *) "self",(char *) "handler", NULL
33313 };
33314
33315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33317 if (!SWIG_IsOK(res1)) {
33318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33319 }
33320 arg1 = reinterpret_cast< wxWindow * >(argp1);
33321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33322 if (!SWIG_IsOK(res2)) {
33323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33324 }
33325 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33326 {
33327 PyThreadState* __tstate = wxPyBeginAllowThreads();
33328 result = (bool)(arg1)->RemoveEventHandler(arg2);
33329 wxPyEndAllowThreads(__tstate);
33330 if (PyErr_Occurred()) SWIG_fail;
33331 }
33332 {
33333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33334 }
33335 return resultobj;
33336 fail:
33337 return NULL;
33338 }
33339
33340
33341 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33342 PyObject *resultobj = 0;
33343 wxWindow *arg1 = (wxWindow *) 0 ;
33344 wxValidator *arg2 = 0 ;
33345 void *argp1 = 0 ;
33346 int res1 = 0 ;
33347 void *argp2 = 0 ;
33348 int res2 = 0 ;
33349 PyObject * obj0 = 0 ;
33350 PyObject * obj1 = 0 ;
33351 char * kwnames[] = {
33352 (char *) "self",(char *) "validator", NULL
33353 };
33354
33355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33357 if (!SWIG_IsOK(res1)) {
33358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33359 }
33360 arg1 = reinterpret_cast< wxWindow * >(argp1);
33361 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33362 if (!SWIG_IsOK(res2)) {
33363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33364 }
33365 if (!argp2) {
33366 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33367 }
33368 arg2 = reinterpret_cast< wxValidator * >(argp2);
33369 {
33370 PyThreadState* __tstate = wxPyBeginAllowThreads();
33371 (arg1)->SetValidator((wxValidator const &)*arg2);
33372 wxPyEndAllowThreads(__tstate);
33373 if (PyErr_Occurred()) SWIG_fail;
33374 }
33375 resultobj = SWIG_Py_Void();
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33383 PyObject *resultobj = 0;
33384 wxWindow *arg1 = (wxWindow *) 0 ;
33385 wxValidator *result = 0 ;
33386 void *argp1 = 0 ;
33387 int res1 = 0 ;
33388 PyObject *swig_obj[1] ;
33389
33390 if (!args) SWIG_fail;
33391 swig_obj[0] = args;
33392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33393 if (!SWIG_IsOK(res1)) {
33394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33395 }
33396 arg1 = reinterpret_cast< wxWindow * >(argp1);
33397 {
33398 PyThreadState* __tstate = wxPyBeginAllowThreads();
33399 result = (wxValidator *)(arg1)->GetValidator();
33400 wxPyEndAllowThreads(__tstate);
33401 if (PyErr_Occurred()) SWIG_fail;
33402 }
33403 {
33404 resultobj = wxPyMake_wxObject(result, (bool)0);
33405 }
33406 return resultobj;
33407 fail:
33408 return NULL;
33409 }
33410
33411
33412 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33413 PyObject *resultobj = 0;
33414 wxWindow *arg1 = (wxWindow *) 0 ;
33415 bool result;
33416 void *argp1 = 0 ;
33417 int res1 = 0 ;
33418 PyObject *swig_obj[1] ;
33419
33420 if (!args) SWIG_fail;
33421 swig_obj[0] = args;
33422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33423 if (!SWIG_IsOK(res1)) {
33424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33425 }
33426 arg1 = reinterpret_cast< wxWindow * >(argp1);
33427 {
33428 PyThreadState* __tstate = wxPyBeginAllowThreads();
33429 result = (bool)(arg1)->Validate();
33430 wxPyEndAllowThreads(__tstate);
33431 if (PyErr_Occurred()) SWIG_fail;
33432 }
33433 {
33434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33435 }
33436 return resultobj;
33437 fail:
33438 return NULL;
33439 }
33440
33441
33442 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33443 PyObject *resultobj = 0;
33444 wxWindow *arg1 = (wxWindow *) 0 ;
33445 bool result;
33446 void *argp1 = 0 ;
33447 int res1 = 0 ;
33448 PyObject *swig_obj[1] ;
33449
33450 if (!args) SWIG_fail;
33451 swig_obj[0] = args;
33452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33453 if (!SWIG_IsOK(res1)) {
33454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33455 }
33456 arg1 = reinterpret_cast< wxWindow * >(argp1);
33457 {
33458 PyThreadState* __tstate = wxPyBeginAllowThreads();
33459 result = (bool)(arg1)->TransferDataToWindow();
33460 wxPyEndAllowThreads(__tstate);
33461 if (PyErr_Occurred()) SWIG_fail;
33462 }
33463 {
33464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33465 }
33466 return resultobj;
33467 fail:
33468 return NULL;
33469 }
33470
33471
33472 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33473 PyObject *resultobj = 0;
33474 wxWindow *arg1 = (wxWindow *) 0 ;
33475 bool result;
33476 void *argp1 = 0 ;
33477 int res1 = 0 ;
33478 PyObject *swig_obj[1] ;
33479
33480 if (!args) SWIG_fail;
33481 swig_obj[0] = args;
33482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33483 if (!SWIG_IsOK(res1)) {
33484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33485 }
33486 arg1 = reinterpret_cast< wxWindow * >(argp1);
33487 {
33488 PyThreadState* __tstate = wxPyBeginAllowThreads();
33489 result = (bool)(arg1)->TransferDataFromWindow();
33490 wxPyEndAllowThreads(__tstate);
33491 if (PyErr_Occurred()) SWIG_fail;
33492 }
33493 {
33494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33495 }
33496 return resultobj;
33497 fail:
33498 return NULL;
33499 }
33500
33501
33502 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33503 PyObject *resultobj = 0;
33504 wxWindow *arg1 = (wxWindow *) 0 ;
33505 void *argp1 = 0 ;
33506 int res1 = 0 ;
33507 PyObject *swig_obj[1] ;
33508
33509 if (!args) SWIG_fail;
33510 swig_obj[0] = args;
33511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33512 if (!SWIG_IsOK(res1)) {
33513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33514 }
33515 arg1 = reinterpret_cast< wxWindow * >(argp1);
33516 {
33517 PyThreadState* __tstate = wxPyBeginAllowThreads();
33518 (arg1)->InitDialog();
33519 wxPyEndAllowThreads(__tstate);
33520 if (PyErr_Occurred()) SWIG_fail;
33521 }
33522 resultobj = SWIG_Py_Void();
33523 return resultobj;
33524 fail:
33525 return NULL;
33526 }
33527
33528
33529 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33530 PyObject *resultobj = 0;
33531 wxWindow *arg1 = (wxWindow *) 0 ;
33532 wxAcceleratorTable *arg2 = 0 ;
33533 void *argp1 = 0 ;
33534 int res1 = 0 ;
33535 void *argp2 = 0 ;
33536 int res2 = 0 ;
33537 PyObject * obj0 = 0 ;
33538 PyObject * obj1 = 0 ;
33539 char * kwnames[] = {
33540 (char *) "self",(char *) "accel", NULL
33541 };
33542
33543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33545 if (!SWIG_IsOK(res1)) {
33546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33547 }
33548 arg1 = reinterpret_cast< wxWindow * >(argp1);
33549 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33550 if (!SWIG_IsOK(res2)) {
33551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33552 }
33553 if (!argp2) {
33554 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33555 }
33556 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33557 {
33558 PyThreadState* __tstate = wxPyBeginAllowThreads();
33559 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33560 wxPyEndAllowThreads(__tstate);
33561 if (PyErr_Occurred()) SWIG_fail;
33562 }
33563 resultobj = SWIG_Py_Void();
33564 return resultobj;
33565 fail:
33566 return NULL;
33567 }
33568
33569
33570 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33571 PyObject *resultobj = 0;
33572 wxWindow *arg1 = (wxWindow *) 0 ;
33573 wxAcceleratorTable *result = 0 ;
33574 void *argp1 = 0 ;
33575 int res1 = 0 ;
33576 PyObject *swig_obj[1] ;
33577
33578 if (!args) SWIG_fail;
33579 swig_obj[0] = args;
33580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33581 if (!SWIG_IsOK(res1)) {
33582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33583 }
33584 arg1 = reinterpret_cast< wxWindow * >(argp1);
33585 {
33586 PyThreadState* __tstate = wxPyBeginAllowThreads();
33587 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33588 wxPyEndAllowThreads(__tstate);
33589 if (PyErr_Occurred()) SWIG_fail;
33590 }
33591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33592 return resultobj;
33593 fail:
33594 return NULL;
33595 }
33596
33597
33598 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33599 PyObject *resultobj = 0;
33600 wxWindow *arg1 = (wxWindow *) 0 ;
33601 int arg2 ;
33602 int arg3 ;
33603 int arg4 ;
33604 bool result;
33605 void *argp1 = 0 ;
33606 int res1 = 0 ;
33607 int val2 ;
33608 int ecode2 = 0 ;
33609 int val3 ;
33610 int ecode3 = 0 ;
33611 int val4 ;
33612 int ecode4 = 0 ;
33613 PyObject * obj0 = 0 ;
33614 PyObject * obj1 = 0 ;
33615 PyObject * obj2 = 0 ;
33616 PyObject * obj3 = 0 ;
33617 char * kwnames[] = {
33618 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33619 };
33620
33621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33623 if (!SWIG_IsOK(res1)) {
33624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33625 }
33626 arg1 = reinterpret_cast< wxWindow * >(argp1);
33627 ecode2 = SWIG_AsVal_int(obj1, &val2);
33628 if (!SWIG_IsOK(ecode2)) {
33629 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33630 }
33631 arg2 = static_cast< int >(val2);
33632 ecode3 = SWIG_AsVal_int(obj2, &val3);
33633 if (!SWIG_IsOK(ecode3)) {
33634 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33635 }
33636 arg3 = static_cast< int >(val3);
33637 ecode4 = SWIG_AsVal_int(obj3, &val4);
33638 if (!SWIG_IsOK(ecode4)) {
33639 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33640 }
33641 arg4 = static_cast< int >(val4);
33642 {
33643 PyThreadState* __tstate = wxPyBeginAllowThreads();
33644 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33645 wxPyEndAllowThreads(__tstate);
33646 if (PyErr_Occurred()) SWIG_fail;
33647 }
33648 {
33649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33650 }
33651 return resultobj;
33652 fail:
33653 return NULL;
33654 }
33655
33656
33657 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33658 PyObject *resultobj = 0;
33659 wxWindow *arg1 = (wxWindow *) 0 ;
33660 int arg2 ;
33661 bool result;
33662 void *argp1 = 0 ;
33663 int res1 = 0 ;
33664 int val2 ;
33665 int ecode2 = 0 ;
33666 PyObject * obj0 = 0 ;
33667 PyObject * obj1 = 0 ;
33668 char * kwnames[] = {
33669 (char *) "self",(char *) "hotkeyId", NULL
33670 };
33671
33672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33674 if (!SWIG_IsOK(res1)) {
33675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33676 }
33677 arg1 = reinterpret_cast< wxWindow * >(argp1);
33678 ecode2 = SWIG_AsVal_int(obj1, &val2);
33679 if (!SWIG_IsOK(ecode2)) {
33680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33681 }
33682 arg2 = static_cast< int >(val2);
33683 {
33684 PyThreadState* __tstate = wxPyBeginAllowThreads();
33685 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33686 wxPyEndAllowThreads(__tstate);
33687 if (PyErr_Occurred()) SWIG_fail;
33688 }
33689 {
33690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33691 }
33692 return resultobj;
33693 fail:
33694 return NULL;
33695 }
33696
33697
33698 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33699 PyObject *resultobj = 0;
33700 wxWindow *arg1 = (wxWindow *) 0 ;
33701 wxPoint *arg2 = 0 ;
33702 wxPoint result;
33703 void *argp1 = 0 ;
33704 int res1 = 0 ;
33705 wxPoint temp2 ;
33706 PyObject * obj0 = 0 ;
33707 PyObject * obj1 = 0 ;
33708 char * kwnames[] = {
33709 (char *) "self",(char *) "pt", NULL
33710 };
33711
33712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33714 if (!SWIG_IsOK(res1)) {
33715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33716 }
33717 arg1 = reinterpret_cast< wxWindow * >(argp1);
33718 {
33719 arg2 = &temp2;
33720 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33721 }
33722 {
33723 PyThreadState* __tstate = wxPyBeginAllowThreads();
33724 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33725 wxPyEndAllowThreads(__tstate);
33726 if (PyErr_Occurred()) SWIG_fail;
33727 }
33728 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33729 return resultobj;
33730 fail:
33731 return NULL;
33732 }
33733
33734
33735 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33736 PyObject *resultobj = 0;
33737 wxWindow *arg1 = (wxWindow *) 0 ;
33738 wxSize *arg2 = 0 ;
33739 wxSize result;
33740 void *argp1 = 0 ;
33741 int res1 = 0 ;
33742 wxSize temp2 ;
33743 PyObject * obj0 = 0 ;
33744 PyObject * obj1 = 0 ;
33745 char * kwnames[] = {
33746 (char *) "self",(char *) "sz", NULL
33747 };
33748
33749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33751 if (!SWIG_IsOK(res1)) {
33752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33753 }
33754 arg1 = reinterpret_cast< wxWindow * >(argp1);
33755 {
33756 arg2 = &temp2;
33757 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33758 }
33759 {
33760 PyThreadState* __tstate = wxPyBeginAllowThreads();
33761 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33762 wxPyEndAllowThreads(__tstate);
33763 if (PyErr_Occurred()) SWIG_fail;
33764 }
33765 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33766 return resultobj;
33767 fail:
33768 return NULL;
33769 }
33770
33771
33772 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33773 PyObject *resultobj = 0;
33774 wxWindow *arg1 = (wxWindow *) 0 ;
33775 wxPoint *arg2 = 0 ;
33776 wxPoint result;
33777 void *argp1 = 0 ;
33778 int res1 = 0 ;
33779 wxPoint temp2 ;
33780 PyObject * obj0 = 0 ;
33781 PyObject * obj1 = 0 ;
33782 char * kwnames[] = {
33783 (char *) "self",(char *) "pt", NULL
33784 };
33785
33786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33788 if (!SWIG_IsOK(res1)) {
33789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33790 }
33791 arg1 = reinterpret_cast< wxWindow * >(argp1);
33792 {
33793 arg2 = &temp2;
33794 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33795 }
33796 {
33797 PyThreadState* __tstate = wxPyBeginAllowThreads();
33798 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33799 wxPyEndAllowThreads(__tstate);
33800 if (PyErr_Occurred()) SWIG_fail;
33801 }
33802 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33803 return resultobj;
33804 fail:
33805 return NULL;
33806 }
33807
33808
33809 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33810 PyObject *resultobj = 0;
33811 wxWindow *arg1 = (wxWindow *) 0 ;
33812 wxSize *arg2 = 0 ;
33813 wxSize result;
33814 void *argp1 = 0 ;
33815 int res1 = 0 ;
33816 wxSize temp2 ;
33817 PyObject * obj0 = 0 ;
33818 PyObject * obj1 = 0 ;
33819 char * kwnames[] = {
33820 (char *) "self",(char *) "sz", NULL
33821 };
33822
33823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33825 if (!SWIG_IsOK(res1)) {
33826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33827 }
33828 arg1 = reinterpret_cast< wxWindow * >(argp1);
33829 {
33830 arg2 = &temp2;
33831 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33832 }
33833 {
33834 PyThreadState* __tstate = wxPyBeginAllowThreads();
33835 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33836 wxPyEndAllowThreads(__tstate);
33837 if (PyErr_Occurred()) SWIG_fail;
33838 }
33839 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33840 return resultobj;
33841 fail:
33842 return NULL;
33843 }
33844
33845
33846 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33847 PyObject *resultobj = 0;
33848 wxWindow *arg1 = (wxWindow *) 0 ;
33849 wxPoint *arg2 = 0 ;
33850 wxPoint result;
33851 void *argp1 = 0 ;
33852 int res1 = 0 ;
33853 wxPoint temp2 ;
33854 PyObject * obj0 = 0 ;
33855 PyObject * obj1 = 0 ;
33856 char * kwnames[] = {
33857 (char *) "self",(char *) "pt", NULL
33858 };
33859
33860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33862 if (!SWIG_IsOK(res1)) {
33863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33864 }
33865 arg1 = reinterpret_cast< wxWindow * >(argp1);
33866 {
33867 arg2 = &temp2;
33868 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33869 }
33870 {
33871 PyThreadState* __tstate = wxPyBeginAllowThreads();
33872 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33873 wxPyEndAllowThreads(__tstate);
33874 if (PyErr_Occurred()) SWIG_fail;
33875 }
33876 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33877 return resultobj;
33878 fail:
33879 return NULL;
33880 }
33881
33882
33883 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33884 PyObject *resultobj = 0;
33885 wxWindow *arg1 = (wxWindow *) 0 ;
33886 wxSize *arg2 = 0 ;
33887 wxSize result;
33888 void *argp1 = 0 ;
33889 int res1 = 0 ;
33890 wxSize temp2 ;
33891 PyObject * obj0 = 0 ;
33892 PyObject * obj1 = 0 ;
33893 char * kwnames[] = {
33894 (char *) "self",(char *) "sz", NULL
33895 };
33896
33897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33899 if (!SWIG_IsOK(res1)) {
33900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33901 }
33902 arg1 = reinterpret_cast< wxWindow * >(argp1);
33903 {
33904 arg2 = &temp2;
33905 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33906 }
33907 {
33908 PyThreadState* __tstate = wxPyBeginAllowThreads();
33909 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33910 wxPyEndAllowThreads(__tstate);
33911 if (PyErr_Occurred()) SWIG_fail;
33912 }
33913 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33914 return resultobj;
33915 fail:
33916 return NULL;
33917 }
33918
33919
33920 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33921 PyObject *resultobj = 0;
33922 wxWindow *arg1 = (wxWindow *) 0 ;
33923 int arg2 ;
33924 int arg3 ;
33925 void *argp1 = 0 ;
33926 int res1 = 0 ;
33927 int val2 ;
33928 int ecode2 = 0 ;
33929 int val3 ;
33930 int ecode3 = 0 ;
33931 PyObject * obj0 = 0 ;
33932 PyObject * obj1 = 0 ;
33933 PyObject * obj2 = 0 ;
33934 char * kwnames[] = {
33935 (char *) "self",(char *) "x",(char *) "y", NULL
33936 };
33937
33938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33940 if (!SWIG_IsOK(res1)) {
33941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
33942 }
33943 arg1 = reinterpret_cast< wxWindow * >(argp1);
33944 ecode2 = SWIG_AsVal_int(obj1, &val2);
33945 if (!SWIG_IsOK(ecode2)) {
33946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
33947 }
33948 arg2 = static_cast< int >(val2);
33949 ecode3 = SWIG_AsVal_int(obj2, &val3);
33950 if (!SWIG_IsOK(ecode3)) {
33951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
33952 }
33953 arg3 = static_cast< int >(val3);
33954 {
33955 PyThreadState* __tstate = wxPyBeginAllowThreads();
33956 (arg1)->WarpPointer(arg2,arg3);
33957 wxPyEndAllowThreads(__tstate);
33958 if (PyErr_Occurred()) SWIG_fail;
33959 }
33960 resultobj = SWIG_Py_Void();
33961 return resultobj;
33962 fail:
33963 return NULL;
33964 }
33965
33966
33967 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33968 PyObject *resultobj = 0;
33969 wxWindow *arg1 = (wxWindow *) 0 ;
33970 void *argp1 = 0 ;
33971 int res1 = 0 ;
33972 PyObject *swig_obj[1] ;
33973
33974 if (!args) SWIG_fail;
33975 swig_obj[0] = args;
33976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33977 if (!SWIG_IsOK(res1)) {
33978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33979 }
33980 arg1 = reinterpret_cast< wxWindow * >(argp1);
33981 {
33982 PyThreadState* __tstate = wxPyBeginAllowThreads();
33983 (arg1)->CaptureMouse();
33984 wxPyEndAllowThreads(__tstate);
33985 if (PyErr_Occurred()) SWIG_fail;
33986 }
33987 resultobj = SWIG_Py_Void();
33988 return resultobj;
33989 fail:
33990 return NULL;
33991 }
33992
33993
33994 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33995 PyObject *resultobj = 0;
33996 wxWindow *arg1 = (wxWindow *) 0 ;
33997 void *argp1 = 0 ;
33998 int res1 = 0 ;
33999 PyObject *swig_obj[1] ;
34000
34001 if (!args) SWIG_fail;
34002 swig_obj[0] = args;
34003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34004 if (!SWIG_IsOK(res1)) {
34005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34006 }
34007 arg1 = reinterpret_cast< wxWindow * >(argp1);
34008 {
34009 PyThreadState* __tstate = wxPyBeginAllowThreads();
34010 (arg1)->ReleaseMouse();
34011 wxPyEndAllowThreads(__tstate);
34012 if (PyErr_Occurred()) SWIG_fail;
34013 }
34014 resultobj = SWIG_Py_Void();
34015 return resultobj;
34016 fail:
34017 return NULL;
34018 }
34019
34020
34021 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34022 PyObject *resultobj = 0;
34023 wxWindow *result = 0 ;
34024
34025 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34026 {
34027 if (!wxPyCheckForApp()) SWIG_fail;
34028 PyThreadState* __tstate = wxPyBeginAllowThreads();
34029 result = (wxWindow *)wxWindow::GetCapture();
34030 wxPyEndAllowThreads(__tstate);
34031 if (PyErr_Occurred()) SWIG_fail;
34032 }
34033 {
34034 resultobj = wxPyMake_wxObject(result, 0);
34035 }
34036 return resultobj;
34037 fail:
34038 return NULL;
34039 }
34040
34041
34042 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34043 PyObject *resultobj = 0;
34044 wxWindow *arg1 = (wxWindow *) 0 ;
34045 bool result;
34046 void *argp1 = 0 ;
34047 int res1 = 0 ;
34048 PyObject *swig_obj[1] ;
34049
34050 if (!args) SWIG_fail;
34051 swig_obj[0] = args;
34052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34053 if (!SWIG_IsOK(res1)) {
34054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34055 }
34056 arg1 = reinterpret_cast< wxWindow * >(argp1);
34057 {
34058 PyThreadState* __tstate = wxPyBeginAllowThreads();
34059 result = (bool)((wxWindow const *)arg1)->HasCapture();
34060 wxPyEndAllowThreads(__tstate);
34061 if (PyErr_Occurred()) SWIG_fail;
34062 }
34063 {
34064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34065 }
34066 return resultobj;
34067 fail:
34068 return NULL;
34069 }
34070
34071
34072 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34073 PyObject *resultobj = 0;
34074 wxWindow *arg1 = (wxWindow *) 0 ;
34075 bool arg2 = (bool) true ;
34076 wxRect *arg3 = (wxRect *) NULL ;
34077 void *argp1 = 0 ;
34078 int res1 = 0 ;
34079 bool val2 ;
34080 int ecode2 = 0 ;
34081 void *argp3 = 0 ;
34082 int res3 = 0 ;
34083 PyObject * obj0 = 0 ;
34084 PyObject * obj1 = 0 ;
34085 PyObject * obj2 = 0 ;
34086 char * kwnames[] = {
34087 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34088 };
34089
34090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34092 if (!SWIG_IsOK(res1)) {
34093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34094 }
34095 arg1 = reinterpret_cast< wxWindow * >(argp1);
34096 if (obj1) {
34097 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34098 if (!SWIG_IsOK(ecode2)) {
34099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34100 }
34101 arg2 = static_cast< bool >(val2);
34102 }
34103 if (obj2) {
34104 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34105 if (!SWIG_IsOK(res3)) {
34106 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34107 }
34108 arg3 = reinterpret_cast< wxRect * >(argp3);
34109 }
34110 {
34111 PyThreadState* __tstate = wxPyBeginAllowThreads();
34112 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34113 wxPyEndAllowThreads(__tstate);
34114 if (PyErr_Occurred()) SWIG_fail;
34115 }
34116 resultobj = SWIG_Py_Void();
34117 return resultobj;
34118 fail:
34119 return NULL;
34120 }
34121
34122
34123 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34124 PyObject *resultobj = 0;
34125 wxWindow *arg1 = (wxWindow *) 0 ;
34126 wxRect *arg2 = 0 ;
34127 bool arg3 = (bool) true ;
34128 void *argp1 = 0 ;
34129 int res1 = 0 ;
34130 wxRect temp2 ;
34131 bool val3 ;
34132 int ecode3 = 0 ;
34133 PyObject * obj0 = 0 ;
34134 PyObject * obj1 = 0 ;
34135 PyObject * obj2 = 0 ;
34136 char * kwnames[] = {
34137 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34138 };
34139
34140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34142 if (!SWIG_IsOK(res1)) {
34143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34144 }
34145 arg1 = reinterpret_cast< wxWindow * >(argp1);
34146 {
34147 arg2 = &temp2;
34148 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34149 }
34150 if (obj2) {
34151 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34152 if (!SWIG_IsOK(ecode3)) {
34153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34154 }
34155 arg3 = static_cast< bool >(val3);
34156 }
34157 {
34158 PyThreadState* __tstate = wxPyBeginAllowThreads();
34159 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34160 wxPyEndAllowThreads(__tstate);
34161 if (PyErr_Occurred()) SWIG_fail;
34162 }
34163 resultobj = SWIG_Py_Void();
34164 return resultobj;
34165 fail:
34166 return NULL;
34167 }
34168
34169
34170 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34171 PyObject *resultobj = 0;
34172 wxWindow *arg1 = (wxWindow *) 0 ;
34173 void *argp1 = 0 ;
34174 int res1 = 0 ;
34175 PyObject *swig_obj[1] ;
34176
34177 if (!args) SWIG_fail;
34178 swig_obj[0] = args;
34179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34180 if (!SWIG_IsOK(res1)) {
34181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34182 }
34183 arg1 = reinterpret_cast< wxWindow * >(argp1);
34184 {
34185 PyThreadState* __tstate = wxPyBeginAllowThreads();
34186 (arg1)->Update();
34187 wxPyEndAllowThreads(__tstate);
34188 if (PyErr_Occurred()) SWIG_fail;
34189 }
34190 resultobj = SWIG_Py_Void();
34191 return resultobj;
34192 fail:
34193 return NULL;
34194 }
34195
34196
34197 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34198 PyObject *resultobj = 0;
34199 wxWindow *arg1 = (wxWindow *) 0 ;
34200 void *argp1 = 0 ;
34201 int res1 = 0 ;
34202 PyObject *swig_obj[1] ;
34203
34204 if (!args) SWIG_fail;
34205 swig_obj[0] = args;
34206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34207 if (!SWIG_IsOK(res1)) {
34208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34209 }
34210 arg1 = reinterpret_cast< wxWindow * >(argp1);
34211 {
34212 PyThreadState* __tstate = wxPyBeginAllowThreads();
34213 (arg1)->ClearBackground();
34214 wxPyEndAllowThreads(__tstate);
34215 if (PyErr_Occurred()) SWIG_fail;
34216 }
34217 resultobj = SWIG_Py_Void();
34218 return resultobj;
34219 fail:
34220 return NULL;
34221 }
34222
34223
34224 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34225 PyObject *resultobj = 0;
34226 wxWindow *arg1 = (wxWindow *) 0 ;
34227 void *argp1 = 0 ;
34228 int res1 = 0 ;
34229 PyObject *swig_obj[1] ;
34230
34231 if (!args) SWIG_fail;
34232 swig_obj[0] = args;
34233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34234 if (!SWIG_IsOK(res1)) {
34235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34236 }
34237 arg1 = reinterpret_cast< wxWindow * >(argp1);
34238 {
34239 PyThreadState* __tstate = wxPyBeginAllowThreads();
34240 (arg1)->Freeze();
34241 wxPyEndAllowThreads(__tstate);
34242 if (PyErr_Occurred()) SWIG_fail;
34243 }
34244 resultobj = SWIG_Py_Void();
34245 return resultobj;
34246 fail:
34247 return NULL;
34248 }
34249
34250
34251 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34252 PyObject *resultobj = 0;
34253 wxWindow *arg1 = (wxWindow *) 0 ;
34254 void *argp1 = 0 ;
34255 int res1 = 0 ;
34256 PyObject *swig_obj[1] ;
34257
34258 if (!args) SWIG_fail;
34259 swig_obj[0] = args;
34260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34261 if (!SWIG_IsOK(res1)) {
34262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34263 }
34264 arg1 = reinterpret_cast< wxWindow * >(argp1);
34265 {
34266 PyThreadState* __tstate = wxPyBeginAllowThreads();
34267 (arg1)->Thaw();
34268 wxPyEndAllowThreads(__tstate);
34269 if (PyErr_Occurred()) SWIG_fail;
34270 }
34271 resultobj = SWIG_Py_Void();
34272 return resultobj;
34273 fail:
34274 return NULL;
34275 }
34276
34277
34278 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34279 PyObject *resultobj = 0;
34280 wxWindow *arg1 = (wxWindow *) 0 ;
34281 wxDC *arg2 = 0 ;
34282 void *argp1 = 0 ;
34283 int res1 = 0 ;
34284 void *argp2 = 0 ;
34285 int res2 = 0 ;
34286 PyObject * obj0 = 0 ;
34287 PyObject * obj1 = 0 ;
34288 char * kwnames[] = {
34289 (char *) "self",(char *) "dc", NULL
34290 };
34291
34292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34294 if (!SWIG_IsOK(res1)) {
34295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34296 }
34297 arg1 = reinterpret_cast< wxWindow * >(argp1);
34298 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34299 if (!SWIG_IsOK(res2)) {
34300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34301 }
34302 if (!argp2) {
34303 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34304 }
34305 arg2 = reinterpret_cast< wxDC * >(argp2);
34306 {
34307 PyThreadState* __tstate = wxPyBeginAllowThreads();
34308 (arg1)->PrepareDC(*arg2);
34309 wxPyEndAllowThreads(__tstate);
34310 if (PyErr_Occurred()) SWIG_fail;
34311 }
34312 resultobj = SWIG_Py_Void();
34313 return resultobj;
34314 fail:
34315 return NULL;
34316 }
34317
34318
34319 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34320 PyObject *resultobj = 0;
34321 wxWindow *arg1 = (wxWindow *) 0 ;
34322 wxRegion *result = 0 ;
34323 void *argp1 = 0 ;
34324 int res1 = 0 ;
34325 PyObject *swig_obj[1] ;
34326
34327 if (!args) SWIG_fail;
34328 swig_obj[0] = args;
34329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34330 if (!SWIG_IsOK(res1)) {
34331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34332 }
34333 arg1 = reinterpret_cast< wxWindow * >(argp1);
34334 {
34335 PyThreadState* __tstate = wxPyBeginAllowThreads();
34336 {
34337 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34338 result = (wxRegion *) &_result_ref;
34339 }
34340 wxPyEndAllowThreads(__tstate);
34341 if (PyErr_Occurred()) SWIG_fail;
34342 }
34343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34344 return resultobj;
34345 fail:
34346 return NULL;
34347 }
34348
34349
34350 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34351 PyObject *resultobj = 0;
34352 wxWindow *arg1 = (wxWindow *) 0 ;
34353 wxRect result;
34354 void *argp1 = 0 ;
34355 int res1 = 0 ;
34356 PyObject *swig_obj[1] ;
34357
34358 if (!args) SWIG_fail;
34359 swig_obj[0] = args;
34360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34361 if (!SWIG_IsOK(res1)) {
34362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34363 }
34364 arg1 = reinterpret_cast< wxWindow * >(argp1);
34365 {
34366 PyThreadState* __tstate = wxPyBeginAllowThreads();
34367 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34368 wxPyEndAllowThreads(__tstate);
34369 if (PyErr_Occurred()) SWIG_fail;
34370 }
34371 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34372 return resultobj;
34373 fail:
34374 return NULL;
34375 }
34376
34377
34378 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34379 PyObject *resultobj = 0;
34380 wxWindow *arg1 = (wxWindow *) 0 ;
34381 int arg2 ;
34382 int arg3 ;
34383 int arg4 = (int) 1 ;
34384 int arg5 = (int) 1 ;
34385 bool result;
34386 void *argp1 = 0 ;
34387 int res1 = 0 ;
34388 int val2 ;
34389 int ecode2 = 0 ;
34390 int val3 ;
34391 int ecode3 = 0 ;
34392 int val4 ;
34393 int ecode4 = 0 ;
34394 int val5 ;
34395 int ecode5 = 0 ;
34396 PyObject * obj0 = 0 ;
34397 PyObject * obj1 = 0 ;
34398 PyObject * obj2 = 0 ;
34399 PyObject * obj3 = 0 ;
34400 PyObject * obj4 = 0 ;
34401 char * kwnames[] = {
34402 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34403 };
34404
34405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34407 if (!SWIG_IsOK(res1)) {
34408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34409 }
34410 arg1 = reinterpret_cast< wxWindow * >(argp1);
34411 ecode2 = SWIG_AsVal_int(obj1, &val2);
34412 if (!SWIG_IsOK(ecode2)) {
34413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34414 }
34415 arg2 = static_cast< int >(val2);
34416 ecode3 = SWIG_AsVal_int(obj2, &val3);
34417 if (!SWIG_IsOK(ecode3)) {
34418 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34419 }
34420 arg3 = static_cast< int >(val3);
34421 if (obj3) {
34422 ecode4 = SWIG_AsVal_int(obj3, &val4);
34423 if (!SWIG_IsOK(ecode4)) {
34424 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34425 }
34426 arg4 = static_cast< int >(val4);
34427 }
34428 if (obj4) {
34429 ecode5 = SWIG_AsVal_int(obj4, &val5);
34430 if (!SWIG_IsOK(ecode5)) {
34431 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34432 }
34433 arg5 = static_cast< int >(val5);
34434 }
34435 {
34436 PyThreadState* __tstate = wxPyBeginAllowThreads();
34437 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34438 wxPyEndAllowThreads(__tstate);
34439 if (PyErr_Occurred()) SWIG_fail;
34440 }
34441 {
34442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34443 }
34444 return resultobj;
34445 fail:
34446 return NULL;
34447 }
34448
34449
34450 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34451 PyObject *resultobj = 0;
34452 wxWindow *arg1 = (wxWindow *) 0 ;
34453 wxPoint *arg2 = 0 ;
34454 bool result;
34455 void *argp1 = 0 ;
34456 int res1 = 0 ;
34457 wxPoint temp2 ;
34458 PyObject * obj0 = 0 ;
34459 PyObject * obj1 = 0 ;
34460 char * kwnames[] = {
34461 (char *) "self",(char *) "pt", NULL
34462 };
34463
34464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34466 if (!SWIG_IsOK(res1)) {
34467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34468 }
34469 arg1 = reinterpret_cast< wxWindow * >(argp1);
34470 {
34471 arg2 = &temp2;
34472 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34473 }
34474 {
34475 PyThreadState* __tstate = wxPyBeginAllowThreads();
34476 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34477 wxPyEndAllowThreads(__tstate);
34478 if (PyErr_Occurred()) SWIG_fail;
34479 }
34480 {
34481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34482 }
34483 return resultobj;
34484 fail:
34485 return NULL;
34486 }
34487
34488
34489 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34490 PyObject *resultobj = 0;
34491 wxWindow *arg1 = (wxWindow *) 0 ;
34492 wxRect *arg2 = 0 ;
34493 bool result;
34494 void *argp1 = 0 ;
34495 int res1 = 0 ;
34496 wxRect temp2 ;
34497 PyObject * obj0 = 0 ;
34498 PyObject * obj1 = 0 ;
34499 char * kwnames[] = {
34500 (char *) "self",(char *) "rect", NULL
34501 };
34502
34503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34505 if (!SWIG_IsOK(res1)) {
34506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34507 }
34508 arg1 = reinterpret_cast< wxWindow * >(argp1);
34509 {
34510 arg2 = &temp2;
34511 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34512 }
34513 {
34514 PyThreadState* __tstate = wxPyBeginAllowThreads();
34515 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 {
34520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34521 }
34522 return resultobj;
34523 fail:
34524 return NULL;
34525 }
34526
34527
34528 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34529 PyObject *resultobj = 0;
34530 wxWindow *arg1 = (wxWindow *) 0 ;
34531 SwigValueWrapper<wxVisualAttributes > result;
34532 void *argp1 = 0 ;
34533 int res1 = 0 ;
34534 PyObject *swig_obj[1] ;
34535
34536 if (!args) SWIG_fail;
34537 swig_obj[0] = args;
34538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34539 if (!SWIG_IsOK(res1)) {
34540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34541 }
34542 arg1 = reinterpret_cast< wxWindow * >(argp1);
34543 {
34544 PyThreadState* __tstate = wxPyBeginAllowThreads();
34545 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34546 wxPyEndAllowThreads(__tstate);
34547 if (PyErr_Occurred()) SWIG_fail;
34548 }
34549 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34550 return resultobj;
34551 fail:
34552 return NULL;
34553 }
34554
34555
34556 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34557 PyObject *resultobj = 0;
34558 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34559 SwigValueWrapper<wxVisualAttributes > result;
34560 int val1 ;
34561 int ecode1 = 0 ;
34562 PyObject * obj0 = 0 ;
34563 char * kwnames[] = {
34564 (char *) "variant", NULL
34565 };
34566
34567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34568 if (obj0) {
34569 ecode1 = SWIG_AsVal_int(obj0, &val1);
34570 if (!SWIG_IsOK(ecode1)) {
34571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34572 }
34573 arg1 = static_cast< wxWindowVariant >(val1);
34574 }
34575 {
34576 if (!wxPyCheckForApp()) SWIG_fail;
34577 PyThreadState* __tstate = wxPyBeginAllowThreads();
34578 result = wxWindow::GetClassDefaultAttributes(arg1);
34579 wxPyEndAllowThreads(__tstate);
34580 if (PyErr_Occurred()) SWIG_fail;
34581 }
34582 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34583 return resultobj;
34584 fail:
34585 return NULL;
34586 }
34587
34588
34589 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34590 PyObject *resultobj = 0;
34591 wxWindow *arg1 = (wxWindow *) 0 ;
34592 wxColour *arg2 = 0 ;
34593 bool result;
34594 void *argp1 = 0 ;
34595 int res1 = 0 ;
34596 wxColour temp2 ;
34597 PyObject * obj0 = 0 ;
34598 PyObject * obj1 = 0 ;
34599 char * kwnames[] = {
34600 (char *) "self",(char *) "colour", NULL
34601 };
34602
34603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34605 if (!SWIG_IsOK(res1)) {
34606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34607 }
34608 arg1 = reinterpret_cast< wxWindow * >(argp1);
34609 {
34610 arg2 = &temp2;
34611 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34612 }
34613 {
34614 PyThreadState* __tstate = wxPyBeginAllowThreads();
34615 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34616 wxPyEndAllowThreads(__tstate);
34617 if (PyErr_Occurred()) SWIG_fail;
34618 }
34619 {
34620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34621 }
34622 return resultobj;
34623 fail:
34624 return NULL;
34625 }
34626
34627
34628 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34629 PyObject *resultobj = 0;
34630 wxWindow *arg1 = (wxWindow *) 0 ;
34631 wxColour *arg2 = 0 ;
34632 void *argp1 = 0 ;
34633 int res1 = 0 ;
34634 wxColour temp2 ;
34635 PyObject * obj0 = 0 ;
34636 PyObject * obj1 = 0 ;
34637 char * kwnames[] = {
34638 (char *) "self",(char *) "colour", NULL
34639 };
34640
34641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34643 if (!SWIG_IsOK(res1)) {
34644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34645 }
34646 arg1 = reinterpret_cast< wxWindow * >(argp1);
34647 {
34648 arg2 = &temp2;
34649 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34650 }
34651 {
34652 PyThreadState* __tstate = wxPyBeginAllowThreads();
34653 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34654 wxPyEndAllowThreads(__tstate);
34655 if (PyErr_Occurred()) SWIG_fail;
34656 }
34657 resultobj = SWIG_Py_Void();
34658 return resultobj;
34659 fail:
34660 return NULL;
34661 }
34662
34663
34664 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34665 PyObject *resultobj = 0;
34666 wxWindow *arg1 = (wxWindow *) 0 ;
34667 wxColour *arg2 = 0 ;
34668 bool result;
34669 void *argp1 = 0 ;
34670 int res1 = 0 ;
34671 wxColour temp2 ;
34672 PyObject * obj0 = 0 ;
34673 PyObject * obj1 = 0 ;
34674 char * kwnames[] = {
34675 (char *) "self",(char *) "colour", NULL
34676 };
34677
34678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34680 if (!SWIG_IsOK(res1)) {
34681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34682 }
34683 arg1 = reinterpret_cast< wxWindow * >(argp1);
34684 {
34685 arg2 = &temp2;
34686 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34687 }
34688 {
34689 PyThreadState* __tstate = wxPyBeginAllowThreads();
34690 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34691 wxPyEndAllowThreads(__tstate);
34692 if (PyErr_Occurred()) SWIG_fail;
34693 }
34694 {
34695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34696 }
34697 return resultobj;
34698 fail:
34699 return NULL;
34700 }
34701
34702
34703 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34704 PyObject *resultobj = 0;
34705 wxWindow *arg1 = (wxWindow *) 0 ;
34706 wxColour *arg2 = 0 ;
34707 void *argp1 = 0 ;
34708 int res1 = 0 ;
34709 wxColour temp2 ;
34710 PyObject * obj0 = 0 ;
34711 PyObject * obj1 = 0 ;
34712 char * kwnames[] = {
34713 (char *) "self",(char *) "colour", NULL
34714 };
34715
34716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34718 if (!SWIG_IsOK(res1)) {
34719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34720 }
34721 arg1 = reinterpret_cast< wxWindow * >(argp1);
34722 {
34723 arg2 = &temp2;
34724 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34725 }
34726 {
34727 PyThreadState* __tstate = wxPyBeginAllowThreads();
34728 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34729 wxPyEndAllowThreads(__tstate);
34730 if (PyErr_Occurred()) SWIG_fail;
34731 }
34732 resultobj = SWIG_Py_Void();
34733 return resultobj;
34734 fail:
34735 return NULL;
34736 }
34737
34738
34739 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34740 PyObject *resultobj = 0;
34741 wxWindow *arg1 = (wxWindow *) 0 ;
34742 wxColour result;
34743 void *argp1 = 0 ;
34744 int res1 = 0 ;
34745 PyObject *swig_obj[1] ;
34746
34747 if (!args) SWIG_fail;
34748 swig_obj[0] = args;
34749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34750 if (!SWIG_IsOK(res1)) {
34751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34752 }
34753 arg1 = reinterpret_cast< wxWindow * >(argp1);
34754 {
34755 PyThreadState* __tstate = wxPyBeginAllowThreads();
34756 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34757 wxPyEndAllowThreads(__tstate);
34758 if (PyErr_Occurred()) SWIG_fail;
34759 }
34760 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34761 return resultobj;
34762 fail:
34763 return NULL;
34764 }
34765
34766
34767 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34768 PyObject *resultobj = 0;
34769 wxWindow *arg1 = (wxWindow *) 0 ;
34770 wxColour result;
34771 void *argp1 = 0 ;
34772 int res1 = 0 ;
34773 PyObject *swig_obj[1] ;
34774
34775 if (!args) SWIG_fail;
34776 swig_obj[0] = args;
34777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34778 if (!SWIG_IsOK(res1)) {
34779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34780 }
34781 arg1 = reinterpret_cast< wxWindow * >(argp1);
34782 {
34783 PyThreadState* __tstate = wxPyBeginAllowThreads();
34784 result = ((wxWindow const *)arg1)->GetForegroundColour();
34785 wxPyEndAllowThreads(__tstate);
34786 if (PyErr_Occurred()) SWIG_fail;
34787 }
34788 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34789 return resultobj;
34790 fail:
34791 return NULL;
34792 }
34793
34794
34795 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34796 PyObject *resultobj = 0;
34797 wxWindow *arg1 = (wxWindow *) 0 ;
34798 bool result;
34799 void *argp1 = 0 ;
34800 int res1 = 0 ;
34801 PyObject *swig_obj[1] ;
34802
34803 if (!args) SWIG_fail;
34804 swig_obj[0] = args;
34805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34806 if (!SWIG_IsOK(res1)) {
34807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34808 }
34809 arg1 = reinterpret_cast< wxWindow * >(argp1);
34810 {
34811 PyThreadState* __tstate = wxPyBeginAllowThreads();
34812 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34813 wxPyEndAllowThreads(__tstate);
34814 if (PyErr_Occurred()) SWIG_fail;
34815 }
34816 {
34817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34818 }
34819 return resultobj;
34820 fail:
34821 return NULL;
34822 }
34823
34824
34825 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34826 PyObject *resultobj = 0;
34827 wxWindow *arg1 = (wxWindow *) 0 ;
34828 bool result;
34829 void *argp1 = 0 ;
34830 int res1 = 0 ;
34831 PyObject *swig_obj[1] ;
34832
34833 if (!args) SWIG_fail;
34834 swig_obj[0] = args;
34835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34836 if (!SWIG_IsOK(res1)) {
34837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34838 }
34839 arg1 = reinterpret_cast< wxWindow * >(argp1);
34840 {
34841 PyThreadState* __tstate = wxPyBeginAllowThreads();
34842 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34843 wxPyEndAllowThreads(__tstate);
34844 if (PyErr_Occurred()) SWIG_fail;
34845 }
34846 {
34847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34848 }
34849 return resultobj;
34850 fail:
34851 return NULL;
34852 }
34853
34854
34855 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34856 PyObject *resultobj = 0;
34857 wxWindow *arg1 = (wxWindow *) 0 ;
34858 wxBackgroundStyle arg2 ;
34859 bool result;
34860 void *argp1 = 0 ;
34861 int res1 = 0 ;
34862 int val2 ;
34863 int ecode2 = 0 ;
34864 PyObject * obj0 = 0 ;
34865 PyObject * obj1 = 0 ;
34866 char * kwnames[] = {
34867 (char *) "self",(char *) "style", NULL
34868 };
34869
34870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34872 if (!SWIG_IsOK(res1)) {
34873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34874 }
34875 arg1 = reinterpret_cast< wxWindow * >(argp1);
34876 ecode2 = SWIG_AsVal_int(obj1, &val2);
34877 if (!SWIG_IsOK(ecode2)) {
34878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34879 }
34880 arg2 = static_cast< wxBackgroundStyle >(val2);
34881 {
34882 PyThreadState* __tstate = wxPyBeginAllowThreads();
34883 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34884 wxPyEndAllowThreads(__tstate);
34885 if (PyErr_Occurred()) SWIG_fail;
34886 }
34887 {
34888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34889 }
34890 return resultobj;
34891 fail:
34892 return NULL;
34893 }
34894
34895
34896 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34897 PyObject *resultobj = 0;
34898 wxWindow *arg1 = (wxWindow *) 0 ;
34899 wxBackgroundStyle result;
34900 void *argp1 = 0 ;
34901 int res1 = 0 ;
34902 PyObject *swig_obj[1] ;
34903
34904 if (!args) SWIG_fail;
34905 swig_obj[0] = args;
34906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34907 if (!SWIG_IsOK(res1)) {
34908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34909 }
34910 arg1 = reinterpret_cast< wxWindow * >(argp1);
34911 {
34912 PyThreadState* __tstate = wxPyBeginAllowThreads();
34913 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34914 wxPyEndAllowThreads(__tstate);
34915 if (PyErr_Occurred()) SWIG_fail;
34916 }
34917 resultobj = SWIG_From_int(static_cast< int >(result));
34918 return resultobj;
34919 fail:
34920 return NULL;
34921 }
34922
34923
34924 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34925 PyObject *resultobj = 0;
34926 wxWindow *arg1 = (wxWindow *) 0 ;
34927 bool result;
34928 void *argp1 = 0 ;
34929 int res1 = 0 ;
34930 PyObject *swig_obj[1] ;
34931
34932 if (!args) SWIG_fail;
34933 swig_obj[0] = args;
34934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34935 if (!SWIG_IsOK(res1)) {
34936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34937 }
34938 arg1 = reinterpret_cast< wxWindow * >(argp1);
34939 {
34940 PyThreadState* __tstate = wxPyBeginAllowThreads();
34941 result = (bool)(arg1)->HasTransparentBackground();
34942 wxPyEndAllowThreads(__tstate);
34943 if (PyErr_Occurred()) SWIG_fail;
34944 }
34945 {
34946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34947 }
34948 return resultobj;
34949 fail:
34950 return NULL;
34951 }
34952
34953
34954 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34955 PyObject *resultobj = 0;
34956 wxWindow *arg1 = (wxWindow *) 0 ;
34957 wxCursor *arg2 = 0 ;
34958 bool result;
34959 void *argp1 = 0 ;
34960 int res1 = 0 ;
34961 void *argp2 = 0 ;
34962 int res2 = 0 ;
34963 PyObject * obj0 = 0 ;
34964 PyObject * obj1 = 0 ;
34965 char * kwnames[] = {
34966 (char *) "self",(char *) "cursor", NULL
34967 };
34968
34969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
34970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34971 if (!SWIG_IsOK(res1)) {
34972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34973 }
34974 arg1 = reinterpret_cast< wxWindow * >(argp1);
34975 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
34976 if (!SWIG_IsOK(res2)) {
34977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34978 }
34979 if (!argp2) {
34980 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34981 }
34982 arg2 = reinterpret_cast< wxCursor * >(argp2);
34983 {
34984 PyThreadState* __tstate = wxPyBeginAllowThreads();
34985 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
34986 wxPyEndAllowThreads(__tstate);
34987 if (PyErr_Occurred()) SWIG_fail;
34988 }
34989 {
34990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34991 }
34992 return resultobj;
34993 fail:
34994 return NULL;
34995 }
34996
34997
34998 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34999 PyObject *resultobj = 0;
35000 wxWindow *arg1 = (wxWindow *) 0 ;
35001 wxCursor result;
35002 void *argp1 = 0 ;
35003 int res1 = 0 ;
35004 PyObject *swig_obj[1] ;
35005
35006 if (!args) SWIG_fail;
35007 swig_obj[0] = args;
35008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35009 if (!SWIG_IsOK(res1)) {
35010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35011 }
35012 arg1 = reinterpret_cast< wxWindow * >(argp1);
35013 {
35014 PyThreadState* __tstate = wxPyBeginAllowThreads();
35015 result = (arg1)->GetCursor();
35016 wxPyEndAllowThreads(__tstate);
35017 if (PyErr_Occurred()) SWIG_fail;
35018 }
35019 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35020 return resultobj;
35021 fail:
35022 return NULL;
35023 }
35024
35025
35026 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35027 PyObject *resultobj = 0;
35028 wxWindow *arg1 = (wxWindow *) 0 ;
35029 wxFont *arg2 = 0 ;
35030 bool result;
35031 void *argp1 = 0 ;
35032 int res1 = 0 ;
35033 void *argp2 = 0 ;
35034 int res2 = 0 ;
35035 PyObject * obj0 = 0 ;
35036 PyObject * obj1 = 0 ;
35037 char * kwnames[] = {
35038 (char *) "self",(char *) "font", NULL
35039 };
35040
35041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35043 if (!SWIG_IsOK(res1)) {
35044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35045 }
35046 arg1 = reinterpret_cast< wxWindow * >(argp1);
35047 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35048 if (!SWIG_IsOK(res2)) {
35049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35050 }
35051 if (!argp2) {
35052 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35053 }
35054 arg2 = reinterpret_cast< wxFont * >(argp2);
35055 {
35056 PyThreadState* __tstate = wxPyBeginAllowThreads();
35057 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35058 wxPyEndAllowThreads(__tstate);
35059 if (PyErr_Occurred()) SWIG_fail;
35060 }
35061 {
35062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35063 }
35064 return resultobj;
35065 fail:
35066 return NULL;
35067 }
35068
35069
35070 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35071 PyObject *resultobj = 0;
35072 wxWindow *arg1 = (wxWindow *) 0 ;
35073 wxFont *arg2 = 0 ;
35074 void *argp1 = 0 ;
35075 int res1 = 0 ;
35076 void *argp2 = 0 ;
35077 int res2 = 0 ;
35078 PyObject * obj0 = 0 ;
35079 PyObject * obj1 = 0 ;
35080 char * kwnames[] = {
35081 (char *) "self",(char *) "font", NULL
35082 };
35083
35084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35086 if (!SWIG_IsOK(res1)) {
35087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35088 }
35089 arg1 = reinterpret_cast< wxWindow * >(argp1);
35090 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35091 if (!SWIG_IsOK(res2)) {
35092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35093 }
35094 if (!argp2) {
35095 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35096 }
35097 arg2 = reinterpret_cast< wxFont * >(argp2);
35098 {
35099 PyThreadState* __tstate = wxPyBeginAllowThreads();
35100 (arg1)->SetOwnFont((wxFont const &)*arg2);
35101 wxPyEndAllowThreads(__tstate);
35102 if (PyErr_Occurred()) SWIG_fail;
35103 }
35104 resultobj = SWIG_Py_Void();
35105 return resultobj;
35106 fail:
35107 return NULL;
35108 }
35109
35110
35111 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35112 PyObject *resultobj = 0;
35113 wxWindow *arg1 = (wxWindow *) 0 ;
35114 wxFont result;
35115 void *argp1 = 0 ;
35116 int res1 = 0 ;
35117 PyObject *swig_obj[1] ;
35118
35119 if (!args) SWIG_fail;
35120 swig_obj[0] = args;
35121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35122 if (!SWIG_IsOK(res1)) {
35123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35124 }
35125 arg1 = reinterpret_cast< wxWindow * >(argp1);
35126 {
35127 PyThreadState* __tstate = wxPyBeginAllowThreads();
35128 result = (arg1)->GetFont();
35129 wxPyEndAllowThreads(__tstate);
35130 if (PyErr_Occurred()) SWIG_fail;
35131 }
35132 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35133 return resultobj;
35134 fail:
35135 return NULL;
35136 }
35137
35138
35139 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35140 PyObject *resultobj = 0;
35141 wxWindow *arg1 = (wxWindow *) 0 ;
35142 wxCaret *arg2 = (wxCaret *) 0 ;
35143 void *argp1 = 0 ;
35144 int res1 = 0 ;
35145 int res2 = 0 ;
35146 PyObject * obj0 = 0 ;
35147 PyObject * obj1 = 0 ;
35148 char * kwnames[] = {
35149 (char *) "self",(char *) "caret", NULL
35150 };
35151
35152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35154 if (!SWIG_IsOK(res1)) {
35155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35156 }
35157 arg1 = reinterpret_cast< wxWindow * >(argp1);
35158 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35159 if (!SWIG_IsOK(res2)) {
35160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35161 }
35162 {
35163 PyThreadState* __tstate = wxPyBeginAllowThreads();
35164 (arg1)->SetCaret(arg2);
35165 wxPyEndAllowThreads(__tstate);
35166 if (PyErr_Occurred()) SWIG_fail;
35167 }
35168 resultobj = SWIG_Py_Void();
35169 return resultobj;
35170 fail:
35171 return NULL;
35172 }
35173
35174
35175 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35176 PyObject *resultobj = 0;
35177 wxWindow *arg1 = (wxWindow *) 0 ;
35178 wxCaret *result = 0 ;
35179 void *argp1 = 0 ;
35180 int res1 = 0 ;
35181 PyObject *swig_obj[1] ;
35182
35183 if (!args) SWIG_fail;
35184 swig_obj[0] = args;
35185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35186 if (!SWIG_IsOK(res1)) {
35187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35188 }
35189 arg1 = reinterpret_cast< wxWindow * >(argp1);
35190 {
35191 PyThreadState* __tstate = wxPyBeginAllowThreads();
35192 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35193 wxPyEndAllowThreads(__tstate);
35194 if (PyErr_Occurred()) SWIG_fail;
35195 }
35196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35197 return resultobj;
35198 fail:
35199 return NULL;
35200 }
35201
35202
35203 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35204 PyObject *resultobj = 0;
35205 wxWindow *arg1 = (wxWindow *) 0 ;
35206 int result;
35207 void *argp1 = 0 ;
35208 int res1 = 0 ;
35209 PyObject *swig_obj[1] ;
35210
35211 if (!args) SWIG_fail;
35212 swig_obj[0] = args;
35213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35214 if (!SWIG_IsOK(res1)) {
35215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35216 }
35217 arg1 = reinterpret_cast< wxWindow * >(argp1);
35218 {
35219 PyThreadState* __tstate = wxPyBeginAllowThreads();
35220 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35221 wxPyEndAllowThreads(__tstate);
35222 if (PyErr_Occurred()) SWIG_fail;
35223 }
35224 resultobj = SWIG_From_int(static_cast< int >(result));
35225 return resultobj;
35226 fail:
35227 return NULL;
35228 }
35229
35230
35231 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35232 PyObject *resultobj = 0;
35233 wxWindow *arg1 = (wxWindow *) 0 ;
35234 int result;
35235 void *argp1 = 0 ;
35236 int res1 = 0 ;
35237 PyObject *swig_obj[1] ;
35238
35239 if (!args) SWIG_fail;
35240 swig_obj[0] = args;
35241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35242 if (!SWIG_IsOK(res1)) {
35243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35244 }
35245 arg1 = reinterpret_cast< wxWindow * >(argp1);
35246 {
35247 PyThreadState* __tstate = wxPyBeginAllowThreads();
35248 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35249 wxPyEndAllowThreads(__tstate);
35250 if (PyErr_Occurred()) SWIG_fail;
35251 }
35252 resultobj = SWIG_From_int(static_cast< int >(result));
35253 return resultobj;
35254 fail:
35255 return NULL;
35256 }
35257
35258
35259 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35260 PyObject *resultobj = 0;
35261 wxWindow *arg1 = (wxWindow *) 0 ;
35262 wxString *arg2 = 0 ;
35263 int *arg3 = (int *) 0 ;
35264 int *arg4 = (int *) 0 ;
35265 void *argp1 = 0 ;
35266 int res1 = 0 ;
35267 bool temp2 = false ;
35268 int temp3 ;
35269 int res3 = SWIG_TMPOBJ ;
35270 int temp4 ;
35271 int res4 = SWIG_TMPOBJ ;
35272 PyObject * obj0 = 0 ;
35273 PyObject * obj1 = 0 ;
35274 char * kwnames[] = {
35275 (char *) "self",(char *) "string", NULL
35276 };
35277
35278 arg3 = &temp3;
35279 arg4 = &temp4;
35280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35282 if (!SWIG_IsOK(res1)) {
35283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35284 }
35285 arg1 = reinterpret_cast< wxWindow * >(argp1);
35286 {
35287 arg2 = wxString_in_helper(obj1);
35288 if (arg2 == NULL) SWIG_fail;
35289 temp2 = true;
35290 }
35291 {
35292 PyThreadState* __tstate = wxPyBeginAllowThreads();
35293 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35294 wxPyEndAllowThreads(__tstate);
35295 if (PyErr_Occurred()) SWIG_fail;
35296 }
35297 resultobj = SWIG_Py_Void();
35298 if (SWIG_IsTmpObj(res3)) {
35299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35300 } else {
35301 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35303 }
35304 if (SWIG_IsTmpObj(res4)) {
35305 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35306 } else {
35307 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35308 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35309 }
35310 {
35311 if (temp2)
35312 delete arg2;
35313 }
35314 return resultobj;
35315 fail:
35316 {
35317 if (temp2)
35318 delete arg2;
35319 }
35320 return NULL;
35321 }
35322
35323
35324 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35325 PyObject *resultobj = 0;
35326 wxWindow *arg1 = (wxWindow *) 0 ;
35327 wxString *arg2 = 0 ;
35328 int *arg3 = (int *) 0 ;
35329 int *arg4 = (int *) 0 ;
35330 int *arg5 = (int *) 0 ;
35331 int *arg6 = (int *) 0 ;
35332 wxFont *arg7 = (wxFont *) NULL ;
35333 void *argp1 = 0 ;
35334 int res1 = 0 ;
35335 bool temp2 = false ;
35336 int temp3 ;
35337 int res3 = SWIG_TMPOBJ ;
35338 int temp4 ;
35339 int res4 = SWIG_TMPOBJ ;
35340 int temp5 ;
35341 int res5 = SWIG_TMPOBJ ;
35342 int temp6 ;
35343 int res6 = SWIG_TMPOBJ ;
35344 void *argp7 = 0 ;
35345 int res7 = 0 ;
35346 PyObject * obj0 = 0 ;
35347 PyObject * obj1 = 0 ;
35348 PyObject * obj2 = 0 ;
35349 char * kwnames[] = {
35350 (char *) "self",(char *) "string",(char *) "font", NULL
35351 };
35352
35353 arg3 = &temp3;
35354 arg4 = &temp4;
35355 arg5 = &temp5;
35356 arg6 = &temp6;
35357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35359 if (!SWIG_IsOK(res1)) {
35360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35361 }
35362 arg1 = reinterpret_cast< wxWindow * >(argp1);
35363 {
35364 arg2 = wxString_in_helper(obj1);
35365 if (arg2 == NULL) SWIG_fail;
35366 temp2 = true;
35367 }
35368 if (obj2) {
35369 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35370 if (!SWIG_IsOK(res7)) {
35371 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35372 }
35373 arg7 = reinterpret_cast< wxFont * >(argp7);
35374 }
35375 {
35376 PyThreadState* __tstate = wxPyBeginAllowThreads();
35377 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35378 wxPyEndAllowThreads(__tstate);
35379 if (PyErr_Occurred()) SWIG_fail;
35380 }
35381 resultobj = SWIG_Py_Void();
35382 if (SWIG_IsTmpObj(res3)) {
35383 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35384 } else {
35385 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35387 }
35388 if (SWIG_IsTmpObj(res4)) {
35389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35390 } else {
35391 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35393 }
35394 if (SWIG_IsTmpObj(res5)) {
35395 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35396 } else {
35397 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35398 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35399 }
35400 if (SWIG_IsTmpObj(res6)) {
35401 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35402 } else {
35403 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35404 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35405 }
35406 {
35407 if (temp2)
35408 delete arg2;
35409 }
35410 return resultobj;
35411 fail:
35412 {
35413 if (temp2)
35414 delete arg2;
35415 }
35416 return NULL;
35417 }
35418
35419
35420 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35421 PyObject *resultobj = 0;
35422 wxWindow *arg1 = (wxWindow *) 0 ;
35423 int *arg2 = (int *) 0 ;
35424 int *arg3 = (int *) 0 ;
35425 void *argp1 = 0 ;
35426 int res1 = 0 ;
35427 int temp2 ;
35428 int res2 = 0 ;
35429 int temp3 ;
35430 int res3 = 0 ;
35431 PyObject * obj0 = 0 ;
35432 PyObject * obj1 = 0 ;
35433 PyObject * obj2 = 0 ;
35434 char * kwnames[] = {
35435 (char *) "self",(char *) "x",(char *) "y", NULL
35436 };
35437
35438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35440 if (!SWIG_IsOK(res1)) {
35441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35442 }
35443 arg1 = reinterpret_cast< wxWindow * >(argp1);
35444 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35445 int val;
35446 int ecode = SWIG_AsVal_int(obj1, &val);
35447 if (!SWIG_IsOK(ecode)) {
35448 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35449 }
35450 temp2 = static_cast< int >(val);
35451 arg2 = &temp2;
35452 res2 = SWIG_AddTmpMask(ecode);
35453 }
35454 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35455 int val;
35456 int ecode = SWIG_AsVal_int(obj2, &val);
35457 if (!SWIG_IsOK(ecode)) {
35458 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35459 }
35460 temp3 = static_cast< int >(val);
35461 arg3 = &temp3;
35462 res3 = SWIG_AddTmpMask(ecode);
35463 }
35464 {
35465 PyThreadState* __tstate = wxPyBeginAllowThreads();
35466 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35467 wxPyEndAllowThreads(__tstate);
35468 if (PyErr_Occurred()) SWIG_fail;
35469 }
35470 resultobj = SWIG_Py_Void();
35471 if (SWIG_IsTmpObj(res2)) {
35472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35473 } else {
35474 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35476 }
35477 if (SWIG_IsTmpObj(res3)) {
35478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35479 } else {
35480 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35482 }
35483 return resultobj;
35484 fail:
35485 return NULL;
35486 }
35487
35488
35489 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35490 PyObject *resultobj = 0;
35491 wxWindow *arg1 = (wxWindow *) 0 ;
35492 int *arg2 = (int *) 0 ;
35493 int *arg3 = (int *) 0 ;
35494 void *argp1 = 0 ;
35495 int res1 = 0 ;
35496 int temp2 ;
35497 int res2 = 0 ;
35498 int temp3 ;
35499 int res3 = 0 ;
35500 PyObject * obj0 = 0 ;
35501 PyObject * obj1 = 0 ;
35502 PyObject * obj2 = 0 ;
35503 char * kwnames[] = {
35504 (char *) "self",(char *) "x",(char *) "y", NULL
35505 };
35506
35507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35509 if (!SWIG_IsOK(res1)) {
35510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35511 }
35512 arg1 = reinterpret_cast< wxWindow * >(argp1);
35513 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35514 int val;
35515 int ecode = SWIG_AsVal_int(obj1, &val);
35516 if (!SWIG_IsOK(ecode)) {
35517 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35518 }
35519 temp2 = static_cast< int >(val);
35520 arg2 = &temp2;
35521 res2 = SWIG_AddTmpMask(ecode);
35522 }
35523 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35524 int val;
35525 int ecode = SWIG_AsVal_int(obj2, &val);
35526 if (!SWIG_IsOK(ecode)) {
35527 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35528 }
35529 temp3 = static_cast< int >(val);
35530 arg3 = &temp3;
35531 res3 = SWIG_AddTmpMask(ecode);
35532 }
35533 {
35534 PyThreadState* __tstate = wxPyBeginAllowThreads();
35535 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35536 wxPyEndAllowThreads(__tstate);
35537 if (PyErr_Occurred()) SWIG_fail;
35538 }
35539 resultobj = SWIG_Py_Void();
35540 if (SWIG_IsTmpObj(res2)) {
35541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35542 } else {
35543 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35545 }
35546 if (SWIG_IsTmpObj(res3)) {
35547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35548 } else {
35549 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35551 }
35552 return resultobj;
35553 fail:
35554 return NULL;
35555 }
35556
35557
35558 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35559 PyObject *resultobj = 0;
35560 wxWindow *arg1 = (wxWindow *) 0 ;
35561 wxPoint *arg2 = 0 ;
35562 wxPoint result;
35563 void *argp1 = 0 ;
35564 int res1 = 0 ;
35565 wxPoint temp2 ;
35566 PyObject * obj0 = 0 ;
35567 PyObject * obj1 = 0 ;
35568 char * kwnames[] = {
35569 (char *) "self",(char *) "pt", NULL
35570 };
35571
35572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35574 if (!SWIG_IsOK(res1)) {
35575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35576 }
35577 arg1 = reinterpret_cast< wxWindow * >(argp1);
35578 {
35579 arg2 = &temp2;
35580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35581 }
35582 {
35583 PyThreadState* __tstate = wxPyBeginAllowThreads();
35584 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35585 wxPyEndAllowThreads(__tstate);
35586 if (PyErr_Occurred()) SWIG_fail;
35587 }
35588 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35589 return resultobj;
35590 fail:
35591 return NULL;
35592 }
35593
35594
35595 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35596 PyObject *resultobj = 0;
35597 wxWindow *arg1 = (wxWindow *) 0 ;
35598 wxPoint *arg2 = 0 ;
35599 wxPoint result;
35600 void *argp1 = 0 ;
35601 int res1 = 0 ;
35602 wxPoint temp2 ;
35603 PyObject * obj0 = 0 ;
35604 PyObject * obj1 = 0 ;
35605 char * kwnames[] = {
35606 (char *) "self",(char *) "pt", NULL
35607 };
35608
35609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35611 if (!SWIG_IsOK(res1)) {
35612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35613 }
35614 arg1 = reinterpret_cast< wxWindow * >(argp1);
35615 {
35616 arg2 = &temp2;
35617 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35618 }
35619 {
35620 PyThreadState* __tstate = wxPyBeginAllowThreads();
35621 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35622 wxPyEndAllowThreads(__tstate);
35623 if (PyErr_Occurred()) SWIG_fail;
35624 }
35625 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35626 return resultobj;
35627 fail:
35628 return NULL;
35629 }
35630
35631
35632 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35633 PyObject *resultobj = 0;
35634 wxWindow *arg1 = (wxWindow *) 0 ;
35635 int arg2 ;
35636 int arg3 ;
35637 wxHitTest result;
35638 void *argp1 = 0 ;
35639 int res1 = 0 ;
35640 int val2 ;
35641 int ecode2 = 0 ;
35642 int val3 ;
35643 int ecode3 = 0 ;
35644 PyObject * obj0 = 0 ;
35645 PyObject * obj1 = 0 ;
35646 PyObject * obj2 = 0 ;
35647 char * kwnames[] = {
35648 (char *) "self",(char *) "x",(char *) "y", NULL
35649 };
35650
35651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35653 if (!SWIG_IsOK(res1)) {
35654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35655 }
35656 arg1 = reinterpret_cast< wxWindow * >(argp1);
35657 ecode2 = SWIG_AsVal_int(obj1, &val2);
35658 if (!SWIG_IsOK(ecode2)) {
35659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35660 }
35661 arg2 = static_cast< int >(val2);
35662 ecode3 = SWIG_AsVal_int(obj2, &val3);
35663 if (!SWIG_IsOK(ecode3)) {
35664 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35665 }
35666 arg3 = static_cast< int >(val3);
35667 {
35668 PyThreadState* __tstate = wxPyBeginAllowThreads();
35669 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35670 wxPyEndAllowThreads(__tstate);
35671 if (PyErr_Occurred()) SWIG_fail;
35672 }
35673 resultobj = SWIG_From_int(static_cast< int >(result));
35674 return resultobj;
35675 fail:
35676 return NULL;
35677 }
35678
35679
35680 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35681 PyObject *resultobj = 0;
35682 wxWindow *arg1 = (wxWindow *) 0 ;
35683 wxPoint *arg2 = 0 ;
35684 wxHitTest result;
35685 void *argp1 = 0 ;
35686 int res1 = 0 ;
35687 wxPoint temp2 ;
35688 PyObject * obj0 = 0 ;
35689 PyObject * obj1 = 0 ;
35690 char * kwnames[] = {
35691 (char *) "self",(char *) "pt", NULL
35692 };
35693
35694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35696 if (!SWIG_IsOK(res1)) {
35697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35698 }
35699 arg1 = reinterpret_cast< wxWindow * >(argp1);
35700 {
35701 arg2 = &temp2;
35702 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35703 }
35704 {
35705 PyThreadState* __tstate = wxPyBeginAllowThreads();
35706 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35707 wxPyEndAllowThreads(__tstate);
35708 if (PyErr_Occurred()) SWIG_fail;
35709 }
35710 resultobj = SWIG_From_int(static_cast< int >(result));
35711 return resultobj;
35712 fail:
35713 return NULL;
35714 }
35715
35716
35717 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35718 PyObject *resultobj = 0;
35719 wxWindow *arg1 = (wxWindow *) 0 ;
35720 long arg2 ;
35721 wxBorder result;
35722 void *argp1 = 0 ;
35723 int res1 = 0 ;
35724 long val2 ;
35725 int ecode2 = 0 ;
35726
35727 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35729 if (!SWIG_IsOK(res1)) {
35730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35731 }
35732 arg1 = reinterpret_cast< wxWindow * >(argp1);
35733 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35734 if (!SWIG_IsOK(ecode2)) {
35735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35736 }
35737 arg2 = static_cast< long >(val2);
35738 {
35739 PyThreadState* __tstate = wxPyBeginAllowThreads();
35740 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
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__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35752 PyObject *resultobj = 0;
35753 wxWindow *arg1 = (wxWindow *) 0 ;
35754 wxBorder result;
35755 void *argp1 = 0 ;
35756 int res1 = 0 ;
35757
35758 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35760 if (!SWIG_IsOK(res1)) {
35761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35762 }
35763 arg1 = reinterpret_cast< wxWindow * >(argp1);
35764 {
35765 PyThreadState* __tstate = wxPyBeginAllowThreads();
35766 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35767 wxPyEndAllowThreads(__tstate);
35768 if (PyErr_Occurred()) SWIG_fail;
35769 }
35770 resultobj = SWIG_From_int(static_cast< int >(result));
35771 return resultobj;
35772 fail:
35773 return NULL;
35774 }
35775
35776
35777 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35778 int argc;
35779 PyObject *argv[3];
35780
35781 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35782 --argc;
35783 if (argc == 1) {
35784 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35785 }
35786 if (argc == 2) {
35787 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35788 }
35789
35790 fail:
35791 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35792 return NULL;
35793 }
35794
35795
35796 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35797 PyObject *resultobj = 0;
35798 wxWindow *arg1 = (wxWindow *) 0 ;
35799 long arg2 = (long) wxUPDATE_UI_NONE ;
35800 void *argp1 = 0 ;
35801 int res1 = 0 ;
35802 long val2 ;
35803 int ecode2 = 0 ;
35804 PyObject * obj0 = 0 ;
35805 PyObject * obj1 = 0 ;
35806 char * kwnames[] = {
35807 (char *) "self",(char *) "flags", NULL
35808 };
35809
35810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35812 if (!SWIG_IsOK(res1)) {
35813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35814 }
35815 arg1 = reinterpret_cast< wxWindow * >(argp1);
35816 if (obj1) {
35817 ecode2 = SWIG_AsVal_long(obj1, &val2);
35818 if (!SWIG_IsOK(ecode2)) {
35819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35820 }
35821 arg2 = static_cast< long >(val2);
35822 }
35823 {
35824 PyThreadState* __tstate = wxPyBeginAllowThreads();
35825 (arg1)->UpdateWindowUI(arg2);
35826 wxPyEndAllowThreads(__tstate);
35827 if (PyErr_Occurred()) SWIG_fail;
35828 }
35829 resultobj = SWIG_Py_Void();
35830 return resultobj;
35831 fail:
35832 return NULL;
35833 }
35834
35835
35836 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35837 PyObject *resultobj = 0;
35838 wxWindow *arg1 = (wxWindow *) 0 ;
35839 wxMenu *arg2 = (wxMenu *) 0 ;
35840 int arg3 = (int) -1 ;
35841 int arg4 = (int) -1 ;
35842 bool result;
35843 void *argp1 = 0 ;
35844 int res1 = 0 ;
35845 void *argp2 = 0 ;
35846 int res2 = 0 ;
35847 int val3 ;
35848 int ecode3 = 0 ;
35849 int val4 ;
35850 int ecode4 = 0 ;
35851 PyObject * obj0 = 0 ;
35852 PyObject * obj1 = 0 ;
35853 PyObject * obj2 = 0 ;
35854 PyObject * obj3 = 0 ;
35855 char * kwnames[] = {
35856 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35857 };
35858
35859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35861 if (!SWIG_IsOK(res1)) {
35862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35863 }
35864 arg1 = reinterpret_cast< wxWindow * >(argp1);
35865 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35866 if (!SWIG_IsOK(res2)) {
35867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35868 }
35869 arg2 = reinterpret_cast< wxMenu * >(argp2);
35870 if (obj2) {
35871 ecode3 = SWIG_AsVal_int(obj2, &val3);
35872 if (!SWIG_IsOK(ecode3)) {
35873 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35874 }
35875 arg3 = static_cast< int >(val3);
35876 }
35877 if (obj3) {
35878 ecode4 = SWIG_AsVal_int(obj3, &val4);
35879 if (!SWIG_IsOK(ecode4)) {
35880 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35881 }
35882 arg4 = static_cast< int >(val4);
35883 }
35884 {
35885 PyThreadState* __tstate = wxPyBeginAllowThreads();
35886 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35887 wxPyEndAllowThreads(__tstate);
35888 if (PyErr_Occurred()) SWIG_fail;
35889 }
35890 {
35891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35892 }
35893 return resultobj;
35894 fail:
35895 return NULL;
35896 }
35897
35898
35899 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35900 PyObject *resultobj = 0;
35901 wxWindow *arg1 = (wxWindow *) 0 ;
35902 wxMenu *arg2 = (wxMenu *) 0 ;
35903 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35904 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35905 bool result;
35906 void *argp1 = 0 ;
35907 int res1 = 0 ;
35908 void *argp2 = 0 ;
35909 int res2 = 0 ;
35910 wxPoint temp3 ;
35911 PyObject * obj0 = 0 ;
35912 PyObject * obj1 = 0 ;
35913 PyObject * obj2 = 0 ;
35914 char * kwnames[] = {
35915 (char *) "self",(char *) "menu",(char *) "pos", NULL
35916 };
35917
35918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35920 if (!SWIG_IsOK(res1)) {
35921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
35922 }
35923 arg1 = reinterpret_cast< wxWindow * >(argp1);
35924 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35925 if (!SWIG_IsOK(res2)) {
35926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
35927 }
35928 arg2 = reinterpret_cast< wxMenu * >(argp2);
35929 if (obj2) {
35930 {
35931 arg3 = &temp3;
35932 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35933 }
35934 }
35935 {
35936 PyThreadState* __tstate = wxPyBeginAllowThreads();
35937 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
35938 wxPyEndAllowThreads(__tstate);
35939 if (PyErr_Occurred()) SWIG_fail;
35940 }
35941 {
35942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35943 }
35944 return resultobj;
35945 fail:
35946 return NULL;
35947 }
35948
35949
35950 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35951 PyObject *resultobj = 0;
35952 wxWindow *arg1 = (wxWindow *) 0 ;
35953 long result;
35954 void *argp1 = 0 ;
35955 int res1 = 0 ;
35956 PyObject *swig_obj[1] ;
35957
35958 if (!args) SWIG_fail;
35959 swig_obj[0] = args;
35960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35961 if (!SWIG_IsOK(res1)) {
35962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35963 }
35964 arg1 = reinterpret_cast< wxWindow * >(argp1);
35965 {
35966 PyThreadState* __tstate = wxPyBeginAllowThreads();
35967 result = (long)wxWindow_GetHandle(arg1);
35968 wxPyEndAllowThreads(__tstate);
35969 if (PyErr_Occurred()) SWIG_fail;
35970 }
35971 resultobj = SWIG_From_long(static_cast< long >(result));
35972 return resultobj;
35973 fail:
35974 return NULL;
35975 }
35976
35977
35978 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35979 PyObject *resultobj = 0;
35980 wxWindow *arg1 = (wxWindow *) 0 ;
35981 long arg2 ;
35982 void *argp1 = 0 ;
35983 int res1 = 0 ;
35984 long val2 ;
35985 int ecode2 = 0 ;
35986 PyObject * obj0 = 0 ;
35987 PyObject * obj1 = 0 ;
35988 char * kwnames[] = {
35989 (char *) "self",(char *) "handle", NULL
35990 };
35991
35992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
35993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35994 if (!SWIG_IsOK(res1)) {
35995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35996 }
35997 arg1 = reinterpret_cast< wxWindow * >(argp1);
35998 ecode2 = SWIG_AsVal_long(obj1, &val2);
35999 if (!SWIG_IsOK(ecode2)) {
36000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36001 }
36002 arg2 = static_cast< long >(val2);
36003 {
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 wxWindow_AssociateHandle(arg1,arg2);
36006 wxPyEndAllowThreads(__tstate);
36007 if (PyErr_Occurred()) SWIG_fail;
36008 }
36009 resultobj = SWIG_Py_Void();
36010 return resultobj;
36011 fail:
36012 return NULL;
36013 }
36014
36015
36016 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36017 PyObject *resultobj = 0;
36018 wxWindow *arg1 = (wxWindow *) 0 ;
36019 void *argp1 = 0 ;
36020 int res1 = 0 ;
36021 PyObject *swig_obj[1] ;
36022
36023 if (!args) SWIG_fail;
36024 swig_obj[0] = args;
36025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36026 if (!SWIG_IsOK(res1)) {
36027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36028 }
36029 arg1 = reinterpret_cast< wxWindow * >(argp1);
36030 {
36031 PyThreadState* __tstate = wxPyBeginAllowThreads();
36032 (arg1)->DissociateHandle();
36033 wxPyEndAllowThreads(__tstate);
36034 if (PyErr_Occurred()) SWIG_fail;
36035 }
36036 resultobj = SWIG_Py_Void();
36037 return resultobj;
36038 fail:
36039 return NULL;
36040 }
36041
36042
36043 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36044 PyObject *resultobj = 0;
36045 wxWindow *arg1 = (wxWindow *) 0 ;
36046 wxPaintEvent *arg2 = 0 ;
36047 void *argp1 = 0 ;
36048 int res1 = 0 ;
36049 void *argp2 = 0 ;
36050 int res2 = 0 ;
36051 PyObject * obj0 = 0 ;
36052 PyObject * obj1 = 0 ;
36053 char * kwnames[] = {
36054 (char *) "self",(char *) "event", NULL
36055 };
36056
36057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36059 if (!SWIG_IsOK(res1)) {
36060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36061 }
36062 arg1 = reinterpret_cast< wxWindow * >(argp1);
36063 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36064 if (!SWIG_IsOK(res2)) {
36065 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36066 }
36067 if (!argp2) {
36068 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36069 }
36070 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36071 {
36072 PyThreadState* __tstate = wxPyBeginAllowThreads();
36073 (arg1)->OnPaint(*arg2);
36074 wxPyEndAllowThreads(__tstate);
36075 if (PyErr_Occurred()) SWIG_fail;
36076 }
36077 resultobj = SWIG_Py_Void();
36078 return resultobj;
36079 fail:
36080 return NULL;
36081 }
36082
36083
36084 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36085 PyObject *resultobj = 0;
36086 wxWindow *arg1 = (wxWindow *) 0 ;
36087 int arg2 ;
36088 bool result;
36089 void *argp1 = 0 ;
36090 int res1 = 0 ;
36091 int val2 ;
36092 int ecode2 = 0 ;
36093 PyObject * obj0 = 0 ;
36094 PyObject * obj1 = 0 ;
36095 char * kwnames[] = {
36096 (char *) "self",(char *) "orient", NULL
36097 };
36098
36099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36101 if (!SWIG_IsOK(res1)) {
36102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36103 }
36104 arg1 = reinterpret_cast< wxWindow * >(argp1);
36105 ecode2 = SWIG_AsVal_int(obj1, &val2);
36106 if (!SWIG_IsOK(ecode2)) {
36107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36108 }
36109 arg2 = static_cast< int >(val2);
36110 {
36111 PyThreadState* __tstate = wxPyBeginAllowThreads();
36112 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36113 wxPyEndAllowThreads(__tstate);
36114 if (PyErr_Occurred()) SWIG_fail;
36115 }
36116 {
36117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36118 }
36119 return resultobj;
36120 fail:
36121 return NULL;
36122 }
36123
36124
36125 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36126 PyObject *resultobj = 0;
36127 wxWindow *arg1 = (wxWindow *) 0 ;
36128 int arg2 ;
36129 int arg3 ;
36130 int arg4 ;
36131 int arg5 ;
36132 bool arg6 = (bool) true ;
36133 void *argp1 = 0 ;
36134 int res1 = 0 ;
36135 int val2 ;
36136 int ecode2 = 0 ;
36137 int val3 ;
36138 int ecode3 = 0 ;
36139 int val4 ;
36140 int ecode4 = 0 ;
36141 int val5 ;
36142 int ecode5 = 0 ;
36143 bool val6 ;
36144 int ecode6 = 0 ;
36145 PyObject * obj0 = 0 ;
36146 PyObject * obj1 = 0 ;
36147 PyObject * obj2 = 0 ;
36148 PyObject * obj3 = 0 ;
36149 PyObject * obj4 = 0 ;
36150 PyObject * obj5 = 0 ;
36151 char * kwnames[] = {
36152 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36153 };
36154
36155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36157 if (!SWIG_IsOK(res1)) {
36158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36159 }
36160 arg1 = reinterpret_cast< wxWindow * >(argp1);
36161 ecode2 = SWIG_AsVal_int(obj1, &val2);
36162 if (!SWIG_IsOK(ecode2)) {
36163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36164 }
36165 arg2 = static_cast< int >(val2);
36166 ecode3 = SWIG_AsVal_int(obj2, &val3);
36167 if (!SWIG_IsOK(ecode3)) {
36168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36169 }
36170 arg3 = static_cast< int >(val3);
36171 ecode4 = SWIG_AsVal_int(obj3, &val4);
36172 if (!SWIG_IsOK(ecode4)) {
36173 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36174 }
36175 arg4 = static_cast< int >(val4);
36176 ecode5 = SWIG_AsVal_int(obj4, &val5);
36177 if (!SWIG_IsOK(ecode5)) {
36178 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36179 }
36180 arg5 = static_cast< int >(val5);
36181 if (obj5) {
36182 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36183 if (!SWIG_IsOK(ecode6)) {
36184 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36185 }
36186 arg6 = static_cast< bool >(val6);
36187 }
36188 {
36189 PyThreadState* __tstate = wxPyBeginAllowThreads();
36190 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36191 wxPyEndAllowThreads(__tstate);
36192 if (PyErr_Occurred()) SWIG_fail;
36193 }
36194 resultobj = SWIG_Py_Void();
36195 return resultobj;
36196 fail:
36197 return NULL;
36198 }
36199
36200
36201 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36202 PyObject *resultobj = 0;
36203 wxWindow *arg1 = (wxWindow *) 0 ;
36204 int arg2 ;
36205 int arg3 ;
36206 bool arg4 = (bool) true ;
36207 void *argp1 = 0 ;
36208 int res1 = 0 ;
36209 int val2 ;
36210 int ecode2 = 0 ;
36211 int val3 ;
36212 int ecode3 = 0 ;
36213 bool val4 ;
36214 int ecode4 = 0 ;
36215 PyObject * obj0 = 0 ;
36216 PyObject * obj1 = 0 ;
36217 PyObject * obj2 = 0 ;
36218 PyObject * obj3 = 0 ;
36219 char * kwnames[] = {
36220 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36221 };
36222
36223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36225 if (!SWIG_IsOK(res1)) {
36226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36227 }
36228 arg1 = reinterpret_cast< wxWindow * >(argp1);
36229 ecode2 = SWIG_AsVal_int(obj1, &val2);
36230 if (!SWIG_IsOK(ecode2)) {
36231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36232 }
36233 arg2 = static_cast< int >(val2);
36234 ecode3 = SWIG_AsVal_int(obj2, &val3);
36235 if (!SWIG_IsOK(ecode3)) {
36236 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36237 }
36238 arg3 = static_cast< int >(val3);
36239 if (obj3) {
36240 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36241 if (!SWIG_IsOK(ecode4)) {
36242 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36243 }
36244 arg4 = static_cast< bool >(val4);
36245 }
36246 {
36247 PyThreadState* __tstate = wxPyBeginAllowThreads();
36248 (arg1)->SetScrollPos(arg2,arg3,arg4);
36249 wxPyEndAllowThreads(__tstate);
36250 if (PyErr_Occurred()) SWIG_fail;
36251 }
36252 resultobj = SWIG_Py_Void();
36253 return resultobj;
36254 fail:
36255 return NULL;
36256 }
36257
36258
36259 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36260 PyObject *resultobj = 0;
36261 wxWindow *arg1 = (wxWindow *) 0 ;
36262 int arg2 ;
36263 int result;
36264 void *argp1 = 0 ;
36265 int res1 = 0 ;
36266 int val2 ;
36267 int ecode2 = 0 ;
36268 PyObject * obj0 = 0 ;
36269 PyObject * obj1 = 0 ;
36270 char * kwnames[] = {
36271 (char *) "self",(char *) "orientation", NULL
36272 };
36273
36274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36276 if (!SWIG_IsOK(res1)) {
36277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36278 }
36279 arg1 = reinterpret_cast< wxWindow * >(argp1);
36280 ecode2 = SWIG_AsVal_int(obj1, &val2);
36281 if (!SWIG_IsOK(ecode2)) {
36282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36283 }
36284 arg2 = static_cast< int >(val2);
36285 {
36286 PyThreadState* __tstate = wxPyBeginAllowThreads();
36287 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36288 wxPyEndAllowThreads(__tstate);
36289 if (PyErr_Occurred()) SWIG_fail;
36290 }
36291 resultobj = SWIG_From_int(static_cast< int >(result));
36292 return resultobj;
36293 fail:
36294 return NULL;
36295 }
36296
36297
36298 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36299 PyObject *resultobj = 0;
36300 wxWindow *arg1 = (wxWindow *) 0 ;
36301 int arg2 ;
36302 int result;
36303 void *argp1 = 0 ;
36304 int res1 = 0 ;
36305 int val2 ;
36306 int ecode2 = 0 ;
36307 PyObject * obj0 = 0 ;
36308 PyObject * obj1 = 0 ;
36309 char * kwnames[] = {
36310 (char *) "self",(char *) "orientation", NULL
36311 };
36312
36313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36315 if (!SWIG_IsOK(res1)) {
36316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36317 }
36318 arg1 = reinterpret_cast< wxWindow * >(argp1);
36319 ecode2 = SWIG_AsVal_int(obj1, &val2);
36320 if (!SWIG_IsOK(ecode2)) {
36321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36322 }
36323 arg2 = static_cast< int >(val2);
36324 {
36325 PyThreadState* __tstate = wxPyBeginAllowThreads();
36326 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36327 wxPyEndAllowThreads(__tstate);
36328 if (PyErr_Occurred()) SWIG_fail;
36329 }
36330 resultobj = SWIG_From_int(static_cast< int >(result));
36331 return resultobj;
36332 fail:
36333 return NULL;
36334 }
36335
36336
36337 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36338 PyObject *resultobj = 0;
36339 wxWindow *arg1 = (wxWindow *) 0 ;
36340 int arg2 ;
36341 int result;
36342 void *argp1 = 0 ;
36343 int res1 = 0 ;
36344 int val2 ;
36345 int ecode2 = 0 ;
36346 PyObject * obj0 = 0 ;
36347 PyObject * obj1 = 0 ;
36348 char * kwnames[] = {
36349 (char *) "self",(char *) "orientation", NULL
36350 };
36351
36352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36354 if (!SWIG_IsOK(res1)) {
36355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36356 }
36357 arg1 = reinterpret_cast< wxWindow * >(argp1);
36358 ecode2 = SWIG_AsVal_int(obj1, &val2);
36359 if (!SWIG_IsOK(ecode2)) {
36360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36361 }
36362 arg2 = static_cast< int >(val2);
36363 {
36364 PyThreadState* __tstate = wxPyBeginAllowThreads();
36365 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36366 wxPyEndAllowThreads(__tstate);
36367 if (PyErr_Occurred()) SWIG_fail;
36368 }
36369 resultobj = SWIG_From_int(static_cast< int >(result));
36370 return resultobj;
36371 fail:
36372 return NULL;
36373 }
36374
36375
36376 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36377 PyObject *resultobj = 0;
36378 wxWindow *arg1 = (wxWindow *) 0 ;
36379 int arg2 ;
36380 int arg3 ;
36381 wxRect *arg4 = (wxRect *) NULL ;
36382 void *argp1 = 0 ;
36383 int res1 = 0 ;
36384 int val2 ;
36385 int ecode2 = 0 ;
36386 int val3 ;
36387 int ecode3 = 0 ;
36388 void *argp4 = 0 ;
36389 int res4 = 0 ;
36390 PyObject * obj0 = 0 ;
36391 PyObject * obj1 = 0 ;
36392 PyObject * obj2 = 0 ;
36393 PyObject * obj3 = 0 ;
36394 char * kwnames[] = {
36395 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36396 };
36397
36398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36400 if (!SWIG_IsOK(res1)) {
36401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36402 }
36403 arg1 = reinterpret_cast< wxWindow * >(argp1);
36404 ecode2 = SWIG_AsVal_int(obj1, &val2);
36405 if (!SWIG_IsOK(ecode2)) {
36406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36407 }
36408 arg2 = static_cast< int >(val2);
36409 ecode3 = SWIG_AsVal_int(obj2, &val3);
36410 if (!SWIG_IsOK(ecode3)) {
36411 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36412 }
36413 arg3 = static_cast< int >(val3);
36414 if (obj3) {
36415 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36416 if (!SWIG_IsOK(res4)) {
36417 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36418 }
36419 arg4 = reinterpret_cast< wxRect * >(argp4);
36420 }
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36424 wxPyEndAllowThreads(__tstate);
36425 if (PyErr_Occurred()) SWIG_fail;
36426 }
36427 resultobj = SWIG_Py_Void();
36428 return resultobj;
36429 fail:
36430 return NULL;
36431 }
36432
36433
36434 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36435 PyObject *resultobj = 0;
36436 wxWindow *arg1 = (wxWindow *) 0 ;
36437 int arg2 ;
36438 bool result;
36439 void *argp1 = 0 ;
36440 int res1 = 0 ;
36441 int val2 ;
36442 int ecode2 = 0 ;
36443 PyObject * obj0 = 0 ;
36444 PyObject * obj1 = 0 ;
36445 char * kwnames[] = {
36446 (char *) "self",(char *) "lines", NULL
36447 };
36448
36449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36451 if (!SWIG_IsOK(res1)) {
36452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36453 }
36454 arg1 = reinterpret_cast< wxWindow * >(argp1);
36455 ecode2 = SWIG_AsVal_int(obj1, &val2);
36456 if (!SWIG_IsOK(ecode2)) {
36457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36458 }
36459 arg2 = static_cast< int >(val2);
36460 {
36461 PyThreadState* __tstate = wxPyBeginAllowThreads();
36462 result = (bool)(arg1)->ScrollLines(arg2);
36463 wxPyEndAllowThreads(__tstate);
36464 if (PyErr_Occurred()) SWIG_fail;
36465 }
36466 {
36467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36468 }
36469 return resultobj;
36470 fail:
36471 return NULL;
36472 }
36473
36474
36475 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36476 PyObject *resultobj = 0;
36477 wxWindow *arg1 = (wxWindow *) 0 ;
36478 int arg2 ;
36479 bool result;
36480 void *argp1 = 0 ;
36481 int res1 = 0 ;
36482 int val2 ;
36483 int ecode2 = 0 ;
36484 PyObject * obj0 = 0 ;
36485 PyObject * obj1 = 0 ;
36486 char * kwnames[] = {
36487 (char *) "self",(char *) "pages", NULL
36488 };
36489
36490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36492 if (!SWIG_IsOK(res1)) {
36493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36494 }
36495 arg1 = reinterpret_cast< wxWindow * >(argp1);
36496 ecode2 = SWIG_AsVal_int(obj1, &val2);
36497 if (!SWIG_IsOK(ecode2)) {
36498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36499 }
36500 arg2 = static_cast< int >(val2);
36501 {
36502 PyThreadState* __tstate = wxPyBeginAllowThreads();
36503 result = (bool)(arg1)->ScrollPages(arg2);
36504 wxPyEndAllowThreads(__tstate);
36505 if (PyErr_Occurred()) SWIG_fail;
36506 }
36507 {
36508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36509 }
36510 return resultobj;
36511 fail:
36512 return NULL;
36513 }
36514
36515
36516 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36517 PyObject *resultobj = 0;
36518 wxWindow *arg1 = (wxWindow *) 0 ;
36519 bool result;
36520 void *argp1 = 0 ;
36521 int res1 = 0 ;
36522 PyObject *swig_obj[1] ;
36523
36524 if (!args) SWIG_fail;
36525 swig_obj[0] = args;
36526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36527 if (!SWIG_IsOK(res1)) {
36528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36529 }
36530 arg1 = reinterpret_cast< wxWindow * >(argp1);
36531 {
36532 PyThreadState* __tstate = wxPyBeginAllowThreads();
36533 result = (bool)(arg1)->LineUp();
36534 wxPyEndAllowThreads(__tstate);
36535 if (PyErr_Occurred()) SWIG_fail;
36536 }
36537 {
36538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36539 }
36540 return resultobj;
36541 fail:
36542 return NULL;
36543 }
36544
36545
36546 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36547 PyObject *resultobj = 0;
36548 wxWindow *arg1 = (wxWindow *) 0 ;
36549 bool result;
36550 void *argp1 = 0 ;
36551 int res1 = 0 ;
36552 PyObject *swig_obj[1] ;
36553
36554 if (!args) SWIG_fail;
36555 swig_obj[0] = args;
36556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36557 if (!SWIG_IsOK(res1)) {
36558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36559 }
36560 arg1 = reinterpret_cast< wxWindow * >(argp1);
36561 {
36562 PyThreadState* __tstate = wxPyBeginAllowThreads();
36563 result = (bool)(arg1)->LineDown();
36564 wxPyEndAllowThreads(__tstate);
36565 if (PyErr_Occurred()) SWIG_fail;
36566 }
36567 {
36568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36569 }
36570 return resultobj;
36571 fail:
36572 return NULL;
36573 }
36574
36575
36576 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36577 PyObject *resultobj = 0;
36578 wxWindow *arg1 = (wxWindow *) 0 ;
36579 bool result;
36580 void *argp1 = 0 ;
36581 int res1 = 0 ;
36582 PyObject *swig_obj[1] ;
36583
36584 if (!args) SWIG_fail;
36585 swig_obj[0] = args;
36586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36587 if (!SWIG_IsOK(res1)) {
36588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36589 }
36590 arg1 = reinterpret_cast< wxWindow * >(argp1);
36591 {
36592 PyThreadState* __tstate = wxPyBeginAllowThreads();
36593 result = (bool)(arg1)->PageUp();
36594 wxPyEndAllowThreads(__tstate);
36595 if (PyErr_Occurred()) SWIG_fail;
36596 }
36597 {
36598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36599 }
36600 return resultobj;
36601 fail:
36602 return NULL;
36603 }
36604
36605
36606 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36607 PyObject *resultobj = 0;
36608 wxWindow *arg1 = (wxWindow *) 0 ;
36609 bool result;
36610 void *argp1 = 0 ;
36611 int res1 = 0 ;
36612 PyObject *swig_obj[1] ;
36613
36614 if (!args) SWIG_fail;
36615 swig_obj[0] = args;
36616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36617 if (!SWIG_IsOK(res1)) {
36618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36619 }
36620 arg1 = reinterpret_cast< wxWindow * >(argp1);
36621 {
36622 PyThreadState* __tstate = wxPyBeginAllowThreads();
36623 result = (bool)(arg1)->PageDown();
36624 wxPyEndAllowThreads(__tstate);
36625 if (PyErr_Occurred()) SWIG_fail;
36626 }
36627 {
36628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36629 }
36630 return resultobj;
36631 fail:
36632 return NULL;
36633 }
36634
36635
36636 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36637 PyObject *resultobj = 0;
36638 wxWindow *arg1 = (wxWindow *) 0 ;
36639 wxString *arg2 = 0 ;
36640 void *argp1 = 0 ;
36641 int res1 = 0 ;
36642 bool temp2 = false ;
36643 PyObject * obj0 = 0 ;
36644 PyObject * obj1 = 0 ;
36645 char * kwnames[] = {
36646 (char *) "self",(char *) "text", NULL
36647 };
36648
36649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36651 if (!SWIG_IsOK(res1)) {
36652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36653 }
36654 arg1 = reinterpret_cast< wxWindow * >(argp1);
36655 {
36656 arg2 = wxString_in_helper(obj1);
36657 if (arg2 == NULL) SWIG_fail;
36658 temp2 = true;
36659 }
36660 {
36661 PyThreadState* __tstate = wxPyBeginAllowThreads();
36662 (arg1)->SetHelpText((wxString const &)*arg2);
36663 wxPyEndAllowThreads(__tstate);
36664 if (PyErr_Occurred()) SWIG_fail;
36665 }
36666 resultobj = SWIG_Py_Void();
36667 {
36668 if (temp2)
36669 delete arg2;
36670 }
36671 return resultobj;
36672 fail:
36673 {
36674 if (temp2)
36675 delete arg2;
36676 }
36677 return NULL;
36678 }
36679
36680
36681 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36682 PyObject *resultobj = 0;
36683 wxWindow *arg1 = (wxWindow *) 0 ;
36684 wxString *arg2 = 0 ;
36685 void *argp1 = 0 ;
36686 int res1 = 0 ;
36687 bool temp2 = false ;
36688 PyObject * obj0 = 0 ;
36689 PyObject * obj1 = 0 ;
36690 char * kwnames[] = {
36691 (char *) "self",(char *) "text", NULL
36692 };
36693
36694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36696 if (!SWIG_IsOK(res1)) {
36697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36698 }
36699 arg1 = reinterpret_cast< wxWindow * >(argp1);
36700 {
36701 arg2 = wxString_in_helper(obj1);
36702 if (arg2 == NULL) SWIG_fail;
36703 temp2 = true;
36704 }
36705 {
36706 PyThreadState* __tstate = wxPyBeginAllowThreads();
36707 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36708 wxPyEndAllowThreads(__tstate);
36709 if (PyErr_Occurred()) SWIG_fail;
36710 }
36711 resultobj = SWIG_Py_Void();
36712 {
36713 if (temp2)
36714 delete arg2;
36715 }
36716 return resultobj;
36717 fail:
36718 {
36719 if (temp2)
36720 delete arg2;
36721 }
36722 return NULL;
36723 }
36724
36725
36726 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36727 PyObject *resultobj = 0;
36728 wxWindow *arg1 = (wxWindow *) 0 ;
36729 wxString result;
36730 void *argp1 = 0 ;
36731 int res1 = 0 ;
36732 PyObject *swig_obj[1] ;
36733
36734 if (!args) SWIG_fail;
36735 swig_obj[0] = args;
36736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36737 if (!SWIG_IsOK(res1)) {
36738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36739 }
36740 arg1 = reinterpret_cast< wxWindow * >(argp1);
36741 {
36742 PyThreadState* __tstate = wxPyBeginAllowThreads();
36743 result = ((wxWindow const *)arg1)->GetHelpText();
36744 wxPyEndAllowThreads(__tstate);
36745 if (PyErr_Occurred()) SWIG_fail;
36746 }
36747 {
36748 #if wxUSE_UNICODE
36749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36750 #else
36751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36752 #endif
36753 }
36754 return resultobj;
36755 fail:
36756 return NULL;
36757 }
36758
36759
36760 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36761 PyObject *resultobj = 0;
36762 wxWindow *arg1 = (wxWindow *) 0 ;
36763 wxString *arg2 = 0 ;
36764 void *argp1 = 0 ;
36765 int res1 = 0 ;
36766 bool temp2 = false ;
36767 PyObject * obj0 = 0 ;
36768 PyObject * obj1 = 0 ;
36769 char * kwnames[] = {
36770 (char *) "self",(char *) "tip", NULL
36771 };
36772
36773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36775 if (!SWIG_IsOK(res1)) {
36776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36777 }
36778 arg1 = reinterpret_cast< wxWindow * >(argp1);
36779 {
36780 arg2 = wxString_in_helper(obj1);
36781 if (arg2 == NULL) SWIG_fail;
36782 temp2 = true;
36783 }
36784 {
36785 PyThreadState* __tstate = wxPyBeginAllowThreads();
36786 (arg1)->SetToolTip((wxString const &)*arg2);
36787 wxPyEndAllowThreads(__tstate);
36788 if (PyErr_Occurred()) SWIG_fail;
36789 }
36790 resultobj = SWIG_Py_Void();
36791 {
36792 if (temp2)
36793 delete arg2;
36794 }
36795 return resultobj;
36796 fail:
36797 {
36798 if (temp2)
36799 delete arg2;
36800 }
36801 return NULL;
36802 }
36803
36804
36805 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36806 PyObject *resultobj = 0;
36807 wxWindow *arg1 = (wxWindow *) 0 ;
36808 wxToolTip *arg2 = (wxToolTip *) 0 ;
36809 void *argp1 = 0 ;
36810 int res1 = 0 ;
36811 int res2 = 0 ;
36812 PyObject * obj0 = 0 ;
36813 PyObject * obj1 = 0 ;
36814 char * kwnames[] = {
36815 (char *) "self",(char *) "tip", NULL
36816 };
36817
36818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36820 if (!SWIG_IsOK(res1)) {
36821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36822 }
36823 arg1 = reinterpret_cast< wxWindow * >(argp1);
36824 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36825 if (!SWIG_IsOK(res2)) {
36826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36827 }
36828 {
36829 PyThreadState* __tstate = wxPyBeginAllowThreads();
36830 (arg1)->SetToolTip(arg2);
36831 wxPyEndAllowThreads(__tstate);
36832 if (PyErr_Occurred()) SWIG_fail;
36833 }
36834 resultobj = SWIG_Py_Void();
36835 return resultobj;
36836 fail:
36837 return NULL;
36838 }
36839
36840
36841 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36842 PyObject *resultobj = 0;
36843 wxWindow *arg1 = (wxWindow *) 0 ;
36844 wxToolTip *result = 0 ;
36845 void *argp1 = 0 ;
36846 int res1 = 0 ;
36847 PyObject *swig_obj[1] ;
36848
36849 if (!args) SWIG_fail;
36850 swig_obj[0] = args;
36851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36852 if (!SWIG_IsOK(res1)) {
36853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36854 }
36855 arg1 = reinterpret_cast< wxWindow * >(argp1);
36856 {
36857 PyThreadState* __tstate = wxPyBeginAllowThreads();
36858 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36859 wxPyEndAllowThreads(__tstate);
36860 if (PyErr_Occurred()) SWIG_fail;
36861 }
36862 {
36863 resultobj = wxPyMake_wxObject(result, (bool)0);
36864 }
36865 return resultobj;
36866 fail:
36867 return NULL;
36868 }
36869
36870
36871 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36872 PyObject *resultobj = 0;
36873 wxWindow *arg1 = (wxWindow *) 0 ;
36874 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36875 void *argp1 = 0 ;
36876 int res1 = 0 ;
36877 int res2 = 0 ;
36878 PyObject * obj0 = 0 ;
36879 PyObject * obj1 = 0 ;
36880 char * kwnames[] = {
36881 (char *) "self",(char *) "dropTarget", NULL
36882 };
36883
36884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36886 if (!SWIG_IsOK(res1)) {
36887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36888 }
36889 arg1 = reinterpret_cast< wxWindow * >(argp1);
36890 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36891 if (!SWIG_IsOK(res2)) {
36892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36893 }
36894 {
36895 PyThreadState* __tstate = wxPyBeginAllowThreads();
36896 (arg1)->SetDropTarget(arg2);
36897 wxPyEndAllowThreads(__tstate);
36898 if (PyErr_Occurred()) SWIG_fail;
36899 }
36900 resultobj = SWIG_Py_Void();
36901 return resultobj;
36902 fail:
36903 return NULL;
36904 }
36905
36906
36907 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36908 PyObject *resultobj = 0;
36909 wxWindow *arg1 = (wxWindow *) 0 ;
36910 wxPyDropTarget *result = 0 ;
36911 void *argp1 = 0 ;
36912 int res1 = 0 ;
36913 PyObject *swig_obj[1] ;
36914
36915 if (!args) SWIG_fail;
36916 swig_obj[0] = args;
36917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36918 if (!SWIG_IsOK(res1)) {
36919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36920 }
36921 arg1 = reinterpret_cast< wxWindow * >(argp1);
36922 {
36923 PyThreadState* __tstate = wxPyBeginAllowThreads();
36924 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36925 wxPyEndAllowThreads(__tstate);
36926 if (PyErr_Occurred()) SWIG_fail;
36927 }
36928 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36929 return resultobj;
36930 fail:
36931 return NULL;
36932 }
36933
36934
36935 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36936 PyObject *resultobj = 0;
36937 wxWindow *arg1 = (wxWindow *) 0 ;
36938 bool arg2 ;
36939 void *argp1 = 0 ;
36940 int res1 = 0 ;
36941 bool val2 ;
36942 int ecode2 = 0 ;
36943 PyObject * obj0 = 0 ;
36944 PyObject * obj1 = 0 ;
36945 char * kwnames[] = {
36946 (char *) "self",(char *) "accept", NULL
36947 };
36948
36949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36951 if (!SWIG_IsOK(res1)) {
36952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36953 }
36954 arg1 = reinterpret_cast< wxWindow * >(argp1);
36955 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36956 if (!SWIG_IsOK(ecode2)) {
36957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
36958 }
36959 arg2 = static_cast< bool >(val2);
36960 {
36961 PyThreadState* __tstate = wxPyBeginAllowThreads();
36962 (arg1)->DragAcceptFiles(arg2);
36963 wxPyEndAllowThreads(__tstate);
36964 if (PyErr_Occurred()) SWIG_fail;
36965 }
36966 resultobj = SWIG_Py_Void();
36967 return resultobj;
36968 fail:
36969 return NULL;
36970 }
36971
36972
36973 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36974 PyObject *resultobj = 0;
36975 wxWindow *arg1 = (wxWindow *) 0 ;
36976 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
36977 void *argp1 = 0 ;
36978 int res1 = 0 ;
36979 int res2 = 0 ;
36980 PyObject * obj0 = 0 ;
36981 PyObject * obj1 = 0 ;
36982 char * kwnames[] = {
36983 (char *) "self",(char *) "constraints", NULL
36984 };
36985
36986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
36987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36988 if (!SWIG_IsOK(res1)) {
36989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
36990 }
36991 arg1 = reinterpret_cast< wxWindow * >(argp1);
36992 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
36993 if (!SWIG_IsOK(res2)) {
36994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
36995 }
36996 {
36997 PyThreadState* __tstate = wxPyBeginAllowThreads();
36998 (arg1)->SetConstraints(arg2);
36999 wxPyEndAllowThreads(__tstate);
37000 if (PyErr_Occurred()) SWIG_fail;
37001 }
37002 resultobj = SWIG_Py_Void();
37003 return resultobj;
37004 fail:
37005 return NULL;
37006 }
37007
37008
37009 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37010 PyObject *resultobj = 0;
37011 wxWindow *arg1 = (wxWindow *) 0 ;
37012 wxLayoutConstraints *result = 0 ;
37013 void *argp1 = 0 ;
37014 int res1 = 0 ;
37015 PyObject *swig_obj[1] ;
37016
37017 if (!args) SWIG_fail;
37018 swig_obj[0] = args;
37019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37020 if (!SWIG_IsOK(res1)) {
37021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37022 }
37023 arg1 = reinterpret_cast< wxWindow * >(argp1);
37024 {
37025 PyThreadState* __tstate = wxPyBeginAllowThreads();
37026 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37027 wxPyEndAllowThreads(__tstate);
37028 if (PyErr_Occurred()) SWIG_fail;
37029 }
37030 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37031 return resultobj;
37032 fail:
37033 return NULL;
37034 }
37035
37036
37037 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37038 PyObject *resultobj = 0;
37039 wxWindow *arg1 = (wxWindow *) 0 ;
37040 bool arg2 ;
37041 void *argp1 = 0 ;
37042 int res1 = 0 ;
37043 bool val2 ;
37044 int ecode2 = 0 ;
37045 PyObject * obj0 = 0 ;
37046 PyObject * obj1 = 0 ;
37047 char * kwnames[] = {
37048 (char *) "self",(char *) "autoLayout", NULL
37049 };
37050
37051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37053 if (!SWIG_IsOK(res1)) {
37054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37055 }
37056 arg1 = reinterpret_cast< wxWindow * >(argp1);
37057 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37058 if (!SWIG_IsOK(ecode2)) {
37059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37060 }
37061 arg2 = static_cast< bool >(val2);
37062 {
37063 PyThreadState* __tstate = wxPyBeginAllowThreads();
37064 (arg1)->SetAutoLayout(arg2);
37065 wxPyEndAllowThreads(__tstate);
37066 if (PyErr_Occurred()) SWIG_fail;
37067 }
37068 resultobj = SWIG_Py_Void();
37069 return resultobj;
37070 fail:
37071 return NULL;
37072 }
37073
37074
37075 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37076 PyObject *resultobj = 0;
37077 wxWindow *arg1 = (wxWindow *) 0 ;
37078 bool result;
37079 void *argp1 = 0 ;
37080 int res1 = 0 ;
37081 PyObject *swig_obj[1] ;
37082
37083 if (!args) SWIG_fail;
37084 swig_obj[0] = args;
37085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37086 if (!SWIG_IsOK(res1)) {
37087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37088 }
37089 arg1 = reinterpret_cast< wxWindow * >(argp1);
37090 {
37091 PyThreadState* __tstate = wxPyBeginAllowThreads();
37092 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37093 wxPyEndAllowThreads(__tstate);
37094 if (PyErr_Occurred()) SWIG_fail;
37095 }
37096 {
37097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37098 }
37099 return resultobj;
37100 fail:
37101 return NULL;
37102 }
37103
37104
37105 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37106 PyObject *resultobj = 0;
37107 wxWindow *arg1 = (wxWindow *) 0 ;
37108 bool result;
37109 void *argp1 = 0 ;
37110 int res1 = 0 ;
37111 PyObject *swig_obj[1] ;
37112
37113 if (!args) SWIG_fail;
37114 swig_obj[0] = args;
37115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37116 if (!SWIG_IsOK(res1)) {
37117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37118 }
37119 arg1 = reinterpret_cast< wxWindow * >(argp1);
37120 {
37121 PyThreadState* __tstate = wxPyBeginAllowThreads();
37122 result = (bool)(arg1)->Layout();
37123 wxPyEndAllowThreads(__tstate);
37124 if (PyErr_Occurred()) SWIG_fail;
37125 }
37126 {
37127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37128 }
37129 return resultobj;
37130 fail:
37131 return NULL;
37132 }
37133
37134
37135 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37136 PyObject *resultobj = 0;
37137 wxWindow *arg1 = (wxWindow *) 0 ;
37138 wxSizer *arg2 = (wxSizer *) 0 ;
37139 bool arg3 = (bool) true ;
37140 void *argp1 = 0 ;
37141 int res1 = 0 ;
37142 int res2 = 0 ;
37143 bool val3 ;
37144 int ecode3 = 0 ;
37145 PyObject * obj0 = 0 ;
37146 PyObject * obj1 = 0 ;
37147 PyObject * obj2 = 0 ;
37148 char * kwnames[] = {
37149 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37150 };
37151
37152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37154 if (!SWIG_IsOK(res1)) {
37155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37156 }
37157 arg1 = reinterpret_cast< wxWindow * >(argp1);
37158 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37159 if (!SWIG_IsOK(res2)) {
37160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37161 }
37162 if (obj2) {
37163 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37164 if (!SWIG_IsOK(ecode3)) {
37165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37166 }
37167 arg3 = static_cast< bool >(val3);
37168 }
37169 {
37170 PyThreadState* __tstate = wxPyBeginAllowThreads();
37171 (arg1)->SetSizer(arg2,arg3);
37172 wxPyEndAllowThreads(__tstate);
37173 if (PyErr_Occurred()) SWIG_fail;
37174 }
37175 resultobj = SWIG_Py_Void();
37176 return resultobj;
37177 fail:
37178 return NULL;
37179 }
37180
37181
37182 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37183 PyObject *resultobj = 0;
37184 wxWindow *arg1 = (wxWindow *) 0 ;
37185 wxSizer *arg2 = (wxSizer *) 0 ;
37186 bool arg3 = (bool) true ;
37187 void *argp1 = 0 ;
37188 int res1 = 0 ;
37189 int res2 = 0 ;
37190 bool val3 ;
37191 int ecode3 = 0 ;
37192 PyObject * obj0 = 0 ;
37193 PyObject * obj1 = 0 ;
37194 PyObject * obj2 = 0 ;
37195 char * kwnames[] = {
37196 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37197 };
37198
37199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37201 if (!SWIG_IsOK(res1)) {
37202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37203 }
37204 arg1 = reinterpret_cast< wxWindow * >(argp1);
37205 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37206 if (!SWIG_IsOK(res2)) {
37207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37208 }
37209 if (obj2) {
37210 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37211 if (!SWIG_IsOK(ecode3)) {
37212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37213 }
37214 arg3 = static_cast< bool >(val3);
37215 }
37216 {
37217 PyThreadState* __tstate = wxPyBeginAllowThreads();
37218 (arg1)->SetSizerAndFit(arg2,arg3);
37219 wxPyEndAllowThreads(__tstate);
37220 if (PyErr_Occurred()) SWIG_fail;
37221 }
37222 resultobj = SWIG_Py_Void();
37223 return resultobj;
37224 fail:
37225 return NULL;
37226 }
37227
37228
37229 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37230 PyObject *resultobj = 0;
37231 wxWindow *arg1 = (wxWindow *) 0 ;
37232 wxSizer *result = 0 ;
37233 void *argp1 = 0 ;
37234 int res1 = 0 ;
37235 PyObject *swig_obj[1] ;
37236
37237 if (!args) SWIG_fail;
37238 swig_obj[0] = args;
37239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37240 if (!SWIG_IsOK(res1)) {
37241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37242 }
37243 arg1 = reinterpret_cast< wxWindow * >(argp1);
37244 {
37245 PyThreadState* __tstate = wxPyBeginAllowThreads();
37246 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37247 wxPyEndAllowThreads(__tstate);
37248 if (PyErr_Occurred()) SWIG_fail;
37249 }
37250 {
37251 resultobj = wxPyMake_wxObject(result, (bool)0);
37252 }
37253 return resultobj;
37254 fail:
37255 return NULL;
37256 }
37257
37258
37259 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37260 PyObject *resultobj = 0;
37261 wxWindow *arg1 = (wxWindow *) 0 ;
37262 wxSizer *arg2 = (wxSizer *) 0 ;
37263 void *argp1 = 0 ;
37264 int res1 = 0 ;
37265 void *argp2 = 0 ;
37266 int res2 = 0 ;
37267 PyObject * obj0 = 0 ;
37268 PyObject * obj1 = 0 ;
37269 char * kwnames[] = {
37270 (char *) "self",(char *) "sizer", NULL
37271 };
37272
37273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37275 if (!SWIG_IsOK(res1)) {
37276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37277 }
37278 arg1 = reinterpret_cast< wxWindow * >(argp1);
37279 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37280 if (!SWIG_IsOK(res2)) {
37281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37282 }
37283 arg2 = reinterpret_cast< wxSizer * >(argp2);
37284 {
37285 PyThreadState* __tstate = wxPyBeginAllowThreads();
37286 (arg1)->SetContainingSizer(arg2);
37287 wxPyEndAllowThreads(__tstate);
37288 if (PyErr_Occurred()) SWIG_fail;
37289 }
37290 resultobj = SWIG_Py_Void();
37291 return resultobj;
37292 fail:
37293 return NULL;
37294 }
37295
37296
37297 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37298 PyObject *resultobj = 0;
37299 wxWindow *arg1 = (wxWindow *) 0 ;
37300 wxSizer *result = 0 ;
37301 void *argp1 = 0 ;
37302 int res1 = 0 ;
37303 PyObject *swig_obj[1] ;
37304
37305 if (!args) SWIG_fail;
37306 swig_obj[0] = args;
37307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37308 if (!SWIG_IsOK(res1)) {
37309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37310 }
37311 arg1 = reinterpret_cast< wxWindow * >(argp1);
37312 {
37313 PyThreadState* __tstate = wxPyBeginAllowThreads();
37314 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37315 wxPyEndAllowThreads(__tstate);
37316 if (PyErr_Occurred()) SWIG_fail;
37317 }
37318 {
37319 resultobj = wxPyMake_wxObject(result, (bool)0);
37320 }
37321 return resultobj;
37322 fail:
37323 return NULL;
37324 }
37325
37326
37327 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37328 PyObject *resultobj = 0;
37329 wxWindow *arg1 = (wxWindow *) 0 ;
37330 void *argp1 = 0 ;
37331 int res1 = 0 ;
37332 PyObject *swig_obj[1] ;
37333
37334 if (!args) SWIG_fail;
37335 swig_obj[0] = args;
37336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37337 if (!SWIG_IsOK(res1)) {
37338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37339 }
37340 arg1 = reinterpret_cast< wxWindow * >(argp1);
37341 {
37342 PyThreadState* __tstate = wxPyBeginAllowThreads();
37343 (arg1)->InheritAttributes();
37344 wxPyEndAllowThreads(__tstate);
37345 if (PyErr_Occurred()) SWIG_fail;
37346 }
37347 resultobj = SWIG_Py_Void();
37348 return resultobj;
37349 fail:
37350 return NULL;
37351 }
37352
37353
37354 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37355 PyObject *resultobj = 0;
37356 wxWindow *arg1 = (wxWindow *) 0 ;
37357 bool result;
37358 void *argp1 = 0 ;
37359 int res1 = 0 ;
37360 PyObject *swig_obj[1] ;
37361
37362 if (!args) SWIG_fail;
37363 swig_obj[0] = args;
37364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37365 if (!SWIG_IsOK(res1)) {
37366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37367 }
37368 arg1 = reinterpret_cast< wxWindow * >(argp1);
37369 {
37370 PyThreadState* __tstate = wxPyBeginAllowThreads();
37371 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37372 wxPyEndAllowThreads(__tstate);
37373 if (PyErr_Occurred()) SWIG_fail;
37374 }
37375 {
37376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37377 }
37378 return resultobj;
37379 fail:
37380 return NULL;
37381 }
37382
37383
37384 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37385 PyObject *obj;
37386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37387 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37388 return SWIG_Py_Void();
37389 }
37390
37391 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37392 return SWIG_Python_InitShadowInstance(args);
37393 }
37394
37395 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37396 PyObject *resultobj = 0;
37397 long arg1 ;
37398 wxWindow *arg2 = (wxWindow *) NULL ;
37399 wxWindow *result = 0 ;
37400 long val1 ;
37401 int ecode1 = 0 ;
37402 void *argp2 = 0 ;
37403 int res2 = 0 ;
37404 PyObject * obj0 = 0 ;
37405 PyObject * obj1 = 0 ;
37406 char * kwnames[] = {
37407 (char *) "id",(char *) "parent", NULL
37408 };
37409
37410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37411 ecode1 = SWIG_AsVal_long(obj0, &val1);
37412 if (!SWIG_IsOK(ecode1)) {
37413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37414 }
37415 arg1 = static_cast< long >(val1);
37416 if (obj1) {
37417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37418 if (!SWIG_IsOK(res2)) {
37419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37420 }
37421 arg2 = reinterpret_cast< wxWindow * >(argp2);
37422 }
37423 {
37424 if (!wxPyCheckForApp()) SWIG_fail;
37425 PyThreadState* __tstate = wxPyBeginAllowThreads();
37426 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37427 wxPyEndAllowThreads(__tstate);
37428 if (PyErr_Occurred()) SWIG_fail;
37429 }
37430 {
37431 resultobj = wxPyMake_wxObject(result, 0);
37432 }
37433 return resultobj;
37434 fail:
37435 return NULL;
37436 }
37437
37438
37439 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37440 PyObject *resultobj = 0;
37441 wxString *arg1 = 0 ;
37442 wxWindow *arg2 = (wxWindow *) NULL ;
37443 wxWindow *result = 0 ;
37444 bool temp1 = false ;
37445 void *argp2 = 0 ;
37446 int res2 = 0 ;
37447 PyObject * obj0 = 0 ;
37448 PyObject * obj1 = 0 ;
37449 char * kwnames[] = {
37450 (char *) "name",(char *) "parent", NULL
37451 };
37452
37453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37454 {
37455 arg1 = wxString_in_helper(obj0);
37456 if (arg1 == NULL) SWIG_fail;
37457 temp1 = true;
37458 }
37459 if (obj1) {
37460 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37461 if (!SWIG_IsOK(res2)) {
37462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37463 }
37464 arg2 = reinterpret_cast< wxWindow * >(argp2);
37465 }
37466 {
37467 if (!wxPyCheckForApp()) SWIG_fail;
37468 PyThreadState* __tstate = wxPyBeginAllowThreads();
37469 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37470 wxPyEndAllowThreads(__tstate);
37471 if (PyErr_Occurred()) SWIG_fail;
37472 }
37473 {
37474 resultobj = wxPyMake_wxObject(result, 0);
37475 }
37476 {
37477 if (temp1)
37478 delete arg1;
37479 }
37480 return resultobj;
37481 fail:
37482 {
37483 if (temp1)
37484 delete arg1;
37485 }
37486 return NULL;
37487 }
37488
37489
37490 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37491 PyObject *resultobj = 0;
37492 wxString *arg1 = 0 ;
37493 wxWindow *arg2 = (wxWindow *) NULL ;
37494 wxWindow *result = 0 ;
37495 bool temp1 = false ;
37496 void *argp2 = 0 ;
37497 int res2 = 0 ;
37498 PyObject * obj0 = 0 ;
37499 PyObject * obj1 = 0 ;
37500 char * kwnames[] = {
37501 (char *) "label",(char *) "parent", NULL
37502 };
37503
37504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37505 {
37506 arg1 = wxString_in_helper(obj0);
37507 if (arg1 == NULL) SWIG_fail;
37508 temp1 = true;
37509 }
37510 if (obj1) {
37511 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37512 if (!SWIG_IsOK(res2)) {
37513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37514 }
37515 arg2 = reinterpret_cast< wxWindow * >(argp2);
37516 }
37517 {
37518 if (!wxPyCheckForApp()) SWIG_fail;
37519 PyThreadState* __tstate = wxPyBeginAllowThreads();
37520 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37521 wxPyEndAllowThreads(__tstate);
37522 if (PyErr_Occurred()) SWIG_fail;
37523 }
37524 {
37525 resultobj = wxPyMake_wxObject(result, 0);
37526 }
37527 {
37528 if (temp1)
37529 delete arg1;
37530 }
37531 return resultobj;
37532 fail:
37533 {
37534 if (temp1)
37535 delete arg1;
37536 }
37537 return NULL;
37538 }
37539
37540
37541 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37542 PyObject *resultobj = 0;
37543 wxWindow *arg1 = (wxWindow *) 0 ;
37544 unsigned long arg2 ;
37545 wxWindow *result = 0 ;
37546 void *argp1 = 0 ;
37547 int res1 = 0 ;
37548 unsigned long val2 ;
37549 int ecode2 = 0 ;
37550 PyObject * obj0 = 0 ;
37551 PyObject * obj1 = 0 ;
37552 char * kwnames[] = {
37553 (char *) "parent",(char *) "_hWnd", NULL
37554 };
37555
37556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37558 if (!SWIG_IsOK(res1)) {
37559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37560 }
37561 arg1 = reinterpret_cast< wxWindow * >(argp1);
37562 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37563 if (!SWIG_IsOK(ecode2)) {
37564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37565 }
37566 arg2 = static_cast< unsigned long >(val2);
37567 {
37568 PyThreadState* __tstate = wxPyBeginAllowThreads();
37569 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37570 wxPyEndAllowThreads(__tstate);
37571 if (PyErr_Occurred()) SWIG_fail;
37572 }
37573 {
37574 resultobj = wxPyMake_wxObject(result, 0);
37575 }
37576 return resultobj;
37577 fail:
37578 return NULL;
37579 }
37580
37581
37582 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37583 PyObject *resultobj = 0;
37584 PyObject *result = 0 ;
37585
37586 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37587 {
37588 PyThreadState* __tstate = wxPyBeginAllowThreads();
37589 result = (PyObject *)GetTopLevelWindows();
37590 wxPyEndAllowThreads(__tstate);
37591 if (PyErr_Occurred()) SWIG_fail;
37592 }
37593 resultobj = result;
37594 return resultobj;
37595 fail:
37596 return NULL;
37597 }
37598
37599
37600 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37601 PyObject *resultobj = 0;
37602 wxValidator *result = 0 ;
37603
37604 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37605 {
37606 PyThreadState* __tstate = wxPyBeginAllowThreads();
37607 result = (wxValidator *)new wxValidator();
37608 wxPyEndAllowThreads(__tstate);
37609 if (PyErr_Occurred()) SWIG_fail;
37610 }
37611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37612 return resultobj;
37613 fail:
37614 return NULL;
37615 }
37616
37617
37618 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37619 PyObject *resultobj = 0;
37620 wxValidator *arg1 = (wxValidator *) 0 ;
37621 wxValidator *result = 0 ;
37622 void *argp1 = 0 ;
37623 int res1 = 0 ;
37624 PyObject *swig_obj[1] ;
37625
37626 if (!args) SWIG_fail;
37627 swig_obj[0] = args;
37628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37629 if (!SWIG_IsOK(res1)) {
37630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37631 }
37632 arg1 = reinterpret_cast< wxValidator * >(argp1);
37633 {
37634 PyThreadState* __tstate = wxPyBeginAllowThreads();
37635 result = (wxValidator *)(arg1)->Clone();
37636 wxPyEndAllowThreads(__tstate);
37637 if (PyErr_Occurred()) SWIG_fail;
37638 }
37639 {
37640 resultobj = wxPyMake_wxObject(result, 0);
37641 }
37642 return resultobj;
37643 fail:
37644 return NULL;
37645 }
37646
37647
37648 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37649 PyObject *resultobj = 0;
37650 wxValidator *arg1 = (wxValidator *) 0 ;
37651 wxWindow *arg2 = (wxWindow *) 0 ;
37652 bool result;
37653 void *argp1 = 0 ;
37654 int res1 = 0 ;
37655 void *argp2 = 0 ;
37656 int res2 = 0 ;
37657 PyObject * obj0 = 0 ;
37658 PyObject * obj1 = 0 ;
37659 char * kwnames[] = {
37660 (char *) "self",(char *) "parent", NULL
37661 };
37662
37663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37665 if (!SWIG_IsOK(res1)) {
37666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37667 }
37668 arg1 = reinterpret_cast< wxValidator * >(argp1);
37669 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37670 if (!SWIG_IsOK(res2)) {
37671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37672 }
37673 arg2 = reinterpret_cast< wxWindow * >(argp2);
37674 {
37675 PyThreadState* __tstate = wxPyBeginAllowThreads();
37676 result = (bool)(arg1)->Validate(arg2);
37677 wxPyEndAllowThreads(__tstate);
37678 if (PyErr_Occurred()) SWIG_fail;
37679 }
37680 {
37681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37682 }
37683 return resultobj;
37684 fail:
37685 return NULL;
37686 }
37687
37688
37689 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37690 PyObject *resultobj = 0;
37691 wxValidator *arg1 = (wxValidator *) 0 ;
37692 bool result;
37693 void *argp1 = 0 ;
37694 int res1 = 0 ;
37695 PyObject *swig_obj[1] ;
37696
37697 if (!args) SWIG_fail;
37698 swig_obj[0] = args;
37699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37700 if (!SWIG_IsOK(res1)) {
37701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37702 }
37703 arg1 = reinterpret_cast< wxValidator * >(argp1);
37704 {
37705 PyThreadState* __tstate = wxPyBeginAllowThreads();
37706 result = (bool)(arg1)->TransferToWindow();
37707 wxPyEndAllowThreads(__tstate);
37708 if (PyErr_Occurred()) SWIG_fail;
37709 }
37710 {
37711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37712 }
37713 return resultobj;
37714 fail:
37715 return NULL;
37716 }
37717
37718
37719 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37720 PyObject *resultobj = 0;
37721 wxValidator *arg1 = (wxValidator *) 0 ;
37722 bool result;
37723 void *argp1 = 0 ;
37724 int res1 = 0 ;
37725 PyObject *swig_obj[1] ;
37726
37727 if (!args) SWIG_fail;
37728 swig_obj[0] = args;
37729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37730 if (!SWIG_IsOK(res1)) {
37731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37732 }
37733 arg1 = reinterpret_cast< wxValidator * >(argp1);
37734 {
37735 PyThreadState* __tstate = wxPyBeginAllowThreads();
37736 result = (bool)(arg1)->TransferFromWindow();
37737 wxPyEndAllowThreads(__tstate);
37738 if (PyErr_Occurred()) SWIG_fail;
37739 }
37740 {
37741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37742 }
37743 return resultobj;
37744 fail:
37745 return NULL;
37746 }
37747
37748
37749 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37750 PyObject *resultobj = 0;
37751 wxValidator *arg1 = (wxValidator *) 0 ;
37752 wxWindow *result = 0 ;
37753 void *argp1 = 0 ;
37754 int res1 = 0 ;
37755 PyObject *swig_obj[1] ;
37756
37757 if (!args) SWIG_fail;
37758 swig_obj[0] = args;
37759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37760 if (!SWIG_IsOK(res1)) {
37761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37762 }
37763 arg1 = reinterpret_cast< wxValidator * >(argp1);
37764 {
37765 PyThreadState* __tstate = wxPyBeginAllowThreads();
37766 result = (wxWindow *)(arg1)->GetWindow();
37767 wxPyEndAllowThreads(__tstate);
37768 if (PyErr_Occurred()) SWIG_fail;
37769 }
37770 {
37771 resultobj = wxPyMake_wxObject(result, 0);
37772 }
37773 return resultobj;
37774 fail:
37775 return NULL;
37776 }
37777
37778
37779 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37780 PyObject *resultobj = 0;
37781 wxValidator *arg1 = (wxValidator *) 0 ;
37782 wxWindow *arg2 = (wxWindow *) 0 ;
37783 void *argp1 = 0 ;
37784 int res1 = 0 ;
37785 void *argp2 = 0 ;
37786 int res2 = 0 ;
37787 PyObject * obj0 = 0 ;
37788 PyObject * obj1 = 0 ;
37789 char * kwnames[] = {
37790 (char *) "self",(char *) "window", NULL
37791 };
37792
37793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37795 if (!SWIG_IsOK(res1)) {
37796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37797 }
37798 arg1 = reinterpret_cast< wxValidator * >(argp1);
37799 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37800 if (!SWIG_IsOK(res2)) {
37801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37802 }
37803 arg2 = reinterpret_cast< wxWindow * >(argp2);
37804 {
37805 PyThreadState* __tstate = wxPyBeginAllowThreads();
37806 (arg1)->SetWindow(arg2);
37807 wxPyEndAllowThreads(__tstate);
37808 if (PyErr_Occurred()) SWIG_fail;
37809 }
37810 resultobj = SWIG_Py_Void();
37811 return resultobj;
37812 fail:
37813 return NULL;
37814 }
37815
37816
37817 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37818 PyObject *resultobj = 0;
37819 bool result;
37820
37821 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37822 {
37823 PyThreadState* __tstate = wxPyBeginAllowThreads();
37824 result = (bool)wxValidator::IsSilent();
37825 wxPyEndAllowThreads(__tstate);
37826 if (PyErr_Occurred()) SWIG_fail;
37827 }
37828 {
37829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37830 }
37831 return resultobj;
37832 fail:
37833 return NULL;
37834 }
37835
37836
37837 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37838 PyObject *resultobj = 0;
37839 int arg1 = (int) true ;
37840 int val1 ;
37841 int ecode1 = 0 ;
37842 PyObject * obj0 = 0 ;
37843 char * kwnames[] = {
37844 (char *) "doIt", NULL
37845 };
37846
37847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37848 if (obj0) {
37849 ecode1 = SWIG_AsVal_int(obj0, &val1);
37850 if (!SWIG_IsOK(ecode1)) {
37851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37852 }
37853 arg1 = static_cast< int >(val1);
37854 }
37855 {
37856 PyThreadState* __tstate = wxPyBeginAllowThreads();
37857 wxValidator::SetBellOnError(arg1);
37858 wxPyEndAllowThreads(__tstate);
37859 if (PyErr_Occurred()) SWIG_fail;
37860 }
37861 resultobj = SWIG_Py_Void();
37862 return resultobj;
37863 fail:
37864 return NULL;
37865 }
37866
37867
37868 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37869 PyObject *obj;
37870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37871 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37872 return SWIG_Py_Void();
37873 }
37874
37875 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37876 return SWIG_Python_InitShadowInstance(args);
37877 }
37878
37879 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37880 PyObject *resultobj = 0;
37881 wxPyValidator *result = 0 ;
37882
37883 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37884 {
37885 PyThreadState* __tstate = wxPyBeginAllowThreads();
37886 result = (wxPyValidator *)new wxPyValidator();
37887 wxPyEndAllowThreads(__tstate);
37888 if (PyErr_Occurred()) SWIG_fail;
37889 }
37890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37891 return resultobj;
37892 fail:
37893 return NULL;
37894 }
37895
37896
37897 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37898 PyObject *resultobj = 0;
37899 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37900 PyObject *arg2 = (PyObject *) 0 ;
37901 PyObject *arg3 = (PyObject *) 0 ;
37902 int arg4 = (int) true ;
37903 void *argp1 = 0 ;
37904 int res1 = 0 ;
37905 int val4 ;
37906 int ecode4 = 0 ;
37907 PyObject * obj0 = 0 ;
37908 PyObject * obj1 = 0 ;
37909 PyObject * obj2 = 0 ;
37910 PyObject * obj3 = 0 ;
37911 char * kwnames[] = {
37912 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37913 };
37914
37915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37917 if (!SWIG_IsOK(res1)) {
37918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37919 }
37920 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37921 arg2 = obj1;
37922 arg3 = obj2;
37923 if (obj3) {
37924 ecode4 = SWIG_AsVal_int(obj3, &val4);
37925 if (!SWIG_IsOK(ecode4)) {
37926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37927 }
37928 arg4 = static_cast< int >(val4);
37929 }
37930 {
37931 PyThreadState* __tstate = wxPyBeginAllowThreads();
37932 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37933 wxPyEndAllowThreads(__tstate);
37934 if (PyErr_Occurred()) SWIG_fail;
37935 }
37936 resultobj = SWIG_Py_Void();
37937 return resultobj;
37938 fail:
37939 return NULL;
37940 }
37941
37942
37943 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37944 PyObject *obj;
37945 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37946 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37947 return SWIG_Py_Void();
37948 }
37949
37950 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37951 return SWIG_Python_InitShadowInstance(args);
37952 }
37953
37954 SWIGINTERN int DefaultValidator_set(PyObject *) {
37955 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37956 return 1;
37957 }
37958
37959
37960 SWIGINTERN PyObject *DefaultValidator_get(void) {
37961 PyObject *pyobj = 0;
37962
37963 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
37964 return pyobj;
37965 }
37966
37967
37968 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37969 PyObject *resultobj = 0;
37970 wxString const &arg1_defvalue = wxPyEmptyString ;
37971 wxString *arg1 = (wxString *) &arg1_defvalue ;
37972 long arg2 = (long) 0 ;
37973 wxMenu *result = 0 ;
37974 bool temp1 = false ;
37975 long val2 ;
37976 int ecode2 = 0 ;
37977 PyObject * obj0 = 0 ;
37978 PyObject * obj1 = 0 ;
37979 char * kwnames[] = {
37980 (char *) "title",(char *) "style", NULL
37981 };
37982
37983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
37984 if (obj0) {
37985 {
37986 arg1 = wxString_in_helper(obj0);
37987 if (arg1 == NULL) SWIG_fail;
37988 temp1 = true;
37989 }
37990 }
37991 if (obj1) {
37992 ecode2 = SWIG_AsVal_long(obj1, &val2);
37993 if (!SWIG_IsOK(ecode2)) {
37994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
37995 }
37996 arg2 = static_cast< long >(val2);
37997 }
37998 {
37999 if (!wxPyCheckForApp()) SWIG_fail;
38000 PyThreadState* __tstate = wxPyBeginAllowThreads();
38001 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38002 wxPyEndAllowThreads(__tstate);
38003 if (PyErr_Occurred()) SWIG_fail;
38004 }
38005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38006 {
38007 if (temp1)
38008 delete arg1;
38009 }
38010 return resultobj;
38011 fail:
38012 {
38013 if (temp1)
38014 delete arg1;
38015 }
38016 return NULL;
38017 }
38018
38019
38020 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38021 PyObject *resultobj = 0;
38022 wxMenu *arg1 = (wxMenu *) 0 ;
38023 int arg2 ;
38024 wxString *arg3 = 0 ;
38025 wxString const &arg4_defvalue = wxPyEmptyString ;
38026 wxString *arg4 = (wxString *) &arg4_defvalue ;
38027 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38028 wxMenuItem *result = 0 ;
38029 void *argp1 = 0 ;
38030 int res1 = 0 ;
38031 int val2 ;
38032 int ecode2 = 0 ;
38033 bool temp3 = false ;
38034 bool temp4 = false ;
38035 int val5 ;
38036 int ecode5 = 0 ;
38037 PyObject * obj0 = 0 ;
38038 PyObject * obj1 = 0 ;
38039 PyObject * obj2 = 0 ;
38040 PyObject * obj3 = 0 ;
38041 PyObject * obj4 = 0 ;
38042 char * kwnames[] = {
38043 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38044 };
38045
38046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38048 if (!SWIG_IsOK(res1)) {
38049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38050 }
38051 arg1 = reinterpret_cast< wxMenu * >(argp1);
38052 ecode2 = SWIG_AsVal_int(obj1, &val2);
38053 if (!SWIG_IsOK(ecode2)) {
38054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38055 }
38056 arg2 = static_cast< int >(val2);
38057 {
38058 arg3 = wxString_in_helper(obj2);
38059 if (arg3 == NULL) SWIG_fail;
38060 temp3 = true;
38061 }
38062 if (obj3) {
38063 {
38064 arg4 = wxString_in_helper(obj3);
38065 if (arg4 == NULL) SWIG_fail;
38066 temp4 = true;
38067 }
38068 }
38069 if (obj4) {
38070 ecode5 = SWIG_AsVal_int(obj4, &val5);
38071 if (!SWIG_IsOK(ecode5)) {
38072 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38073 }
38074 arg5 = static_cast< wxItemKind >(val5);
38075 }
38076 {
38077 PyThreadState* __tstate = wxPyBeginAllowThreads();
38078 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38079 wxPyEndAllowThreads(__tstate);
38080 if (PyErr_Occurred()) SWIG_fail;
38081 }
38082 {
38083 resultobj = wxPyMake_wxObject(result, (bool)0);
38084 }
38085 {
38086 if (temp3)
38087 delete arg3;
38088 }
38089 {
38090 if (temp4)
38091 delete arg4;
38092 }
38093 return resultobj;
38094 fail:
38095 {
38096 if (temp3)
38097 delete arg3;
38098 }
38099 {
38100 if (temp4)
38101 delete arg4;
38102 }
38103 return NULL;
38104 }
38105
38106
38107 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38108 PyObject *resultobj = 0;
38109 wxMenu *arg1 = (wxMenu *) 0 ;
38110 wxMenuItem *result = 0 ;
38111 void *argp1 = 0 ;
38112 int res1 = 0 ;
38113 PyObject *swig_obj[1] ;
38114
38115 if (!args) SWIG_fail;
38116 swig_obj[0] = args;
38117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38118 if (!SWIG_IsOK(res1)) {
38119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38120 }
38121 arg1 = reinterpret_cast< wxMenu * >(argp1);
38122 {
38123 PyThreadState* __tstate = wxPyBeginAllowThreads();
38124 result = (wxMenuItem *)(arg1)->AppendSeparator();
38125 wxPyEndAllowThreads(__tstate);
38126 if (PyErr_Occurred()) SWIG_fail;
38127 }
38128 {
38129 resultobj = wxPyMake_wxObject(result, (bool)0);
38130 }
38131 return resultobj;
38132 fail:
38133 return NULL;
38134 }
38135
38136
38137 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38138 PyObject *resultobj = 0;
38139 wxMenu *arg1 = (wxMenu *) 0 ;
38140 int arg2 ;
38141 wxString *arg3 = 0 ;
38142 wxString const &arg4_defvalue = wxPyEmptyString ;
38143 wxString *arg4 = (wxString *) &arg4_defvalue ;
38144 wxMenuItem *result = 0 ;
38145 void *argp1 = 0 ;
38146 int res1 = 0 ;
38147 int val2 ;
38148 int ecode2 = 0 ;
38149 bool temp3 = false ;
38150 bool temp4 = false ;
38151 PyObject * obj0 = 0 ;
38152 PyObject * obj1 = 0 ;
38153 PyObject * obj2 = 0 ;
38154 PyObject * obj3 = 0 ;
38155 char * kwnames[] = {
38156 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38157 };
38158
38159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38161 if (!SWIG_IsOK(res1)) {
38162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38163 }
38164 arg1 = reinterpret_cast< wxMenu * >(argp1);
38165 ecode2 = SWIG_AsVal_int(obj1, &val2);
38166 if (!SWIG_IsOK(ecode2)) {
38167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38168 }
38169 arg2 = static_cast< int >(val2);
38170 {
38171 arg3 = wxString_in_helper(obj2);
38172 if (arg3 == NULL) SWIG_fail;
38173 temp3 = true;
38174 }
38175 if (obj3) {
38176 {
38177 arg4 = wxString_in_helper(obj3);
38178 if (arg4 == NULL) SWIG_fail;
38179 temp4 = true;
38180 }
38181 }
38182 {
38183 PyThreadState* __tstate = wxPyBeginAllowThreads();
38184 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38185 wxPyEndAllowThreads(__tstate);
38186 if (PyErr_Occurred()) SWIG_fail;
38187 }
38188 {
38189 resultobj = wxPyMake_wxObject(result, (bool)0);
38190 }
38191 {
38192 if (temp3)
38193 delete arg3;
38194 }
38195 {
38196 if (temp4)
38197 delete arg4;
38198 }
38199 return resultobj;
38200 fail:
38201 {
38202 if (temp3)
38203 delete arg3;
38204 }
38205 {
38206 if (temp4)
38207 delete arg4;
38208 }
38209 return NULL;
38210 }
38211
38212
38213 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38214 PyObject *resultobj = 0;
38215 wxMenu *arg1 = (wxMenu *) 0 ;
38216 int arg2 ;
38217 wxString *arg3 = 0 ;
38218 wxString const &arg4_defvalue = wxPyEmptyString ;
38219 wxString *arg4 = (wxString *) &arg4_defvalue ;
38220 wxMenuItem *result = 0 ;
38221 void *argp1 = 0 ;
38222 int res1 = 0 ;
38223 int val2 ;
38224 int ecode2 = 0 ;
38225 bool temp3 = false ;
38226 bool temp4 = false ;
38227 PyObject * obj0 = 0 ;
38228 PyObject * obj1 = 0 ;
38229 PyObject * obj2 = 0 ;
38230 PyObject * obj3 = 0 ;
38231 char * kwnames[] = {
38232 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38233 };
38234
38235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38237 if (!SWIG_IsOK(res1)) {
38238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38239 }
38240 arg1 = reinterpret_cast< wxMenu * >(argp1);
38241 ecode2 = SWIG_AsVal_int(obj1, &val2);
38242 if (!SWIG_IsOK(ecode2)) {
38243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38244 }
38245 arg2 = static_cast< int >(val2);
38246 {
38247 arg3 = wxString_in_helper(obj2);
38248 if (arg3 == NULL) SWIG_fail;
38249 temp3 = true;
38250 }
38251 if (obj3) {
38252 {
38253 arg4 = wxString_in_helper(obj3);
38254 if (arg4 == NULL) SWIG_fail;
38255 temp4 = true;
38256 }
38257 }
38258 {
38259 PyThreadState* __tstate = wxPyBeginAllowThreads();
38260 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38261 wxPyEndAllowThreads(__tstate);
38262 if (PyErr_Occurred()) SWIG_fail;
38263 }
38264 {
38265 resultobj = wxPyMake_wxObject(result, (bool)0);
38266 }
38267 {
38268 if (temp3)
38269 delete arg3;
38270 }
38271 {
38272 if (temp4)
38273 delete arg4;
38274 }
38275 return resultobj;
38276 fail:
38277 {
38278 if (temp3)
38279 delete arg3;
38280 }
38281 {
38282 if (temp4)
38283 delete arg4;
38284 }
38285 return NULL;
38286 }
38287
38288
38289 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38290 PyObject *resultobj = 0;
38291 wxMenu *arg1 = (wxMenu *) 0 ;
38292 int arg2 ;
38293 wxString *arg3 = 0 ;
38294 wxMenu *arg4 = (wxMenu *) 0 ;
38295 wxString const &arg5_defvalue = wxPyEmptyString ;
38296 wxString *arg5 = (wxString *) &arg5_defvalue ;
38297 wxMenuItem *result = 0 ;
38298 void *argp1 = 0 ;
38299 int res1 = 0 ;
38300 int val2 ;
38301 int ecode2 = 0 ;
38302 bool temp3 = false ;
38303 void *argp4 = 0 ;
38304 int res4 = 0 ;
38305 bool temp5 = false ;
38306 PyObject * obj0 = 0 ;
38307 PyObject * obj1 = 0 ;
38308 PyObject * obj2 = 0 ;
38309 PyObject * obj3 = 0 ;
38310 PyObject * obj4 = 0 ;
38311 char * kwnames[] = {
38312 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38313 };
38314
38315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38317 if (!SWIG_IsOK(res1)) {
38318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38319 }
38320 arg1 = reinterpret_cast< wxMenu * >(argp1);
38321 ecode2 = SWIG_AsVal_int(obj1, &val2);
38322 if (!SWIG_IsOK(ecode2)) {
38323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38324 }
38325 arg2 = static_cast< int >(val2);
38326 {
38327 arg3 = wxString_in_helper(obj2);
38328 if (arg3 == NULL) SWIG_fail;
38329 temp3 = true;
38330 }
38331 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38332 if (!SWIG_IsOK(res4)) {
38333 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38334 }
38335 arg4 = reinterpret_cast< wxMenu * >(argp4);
38336 if (obj4) {
38337 {
38338 arg5 = wxString_in_helper(obj4);
38339 if (arg5 == NULL) SWIG_fail;
38340 temp5 = true;
38341 }
38342 }
38343 {
38344 PyThreadState* __tstate = wxPyBeginAllowThreads();
38345 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38346 wxPyEndAllowThreads(__tstate);
38347 if (PyErr_Occurred()) SWIG_fail;
38348 }
38349 {
38350 resultobj = wxPyMake_wxObject(result, (bool)0);
38351 }
38352 {
38353 if (temp3)
38354 delete arg3;
38355 }
38356 {
38357 if (temp5)
38358 delete arg5;
38359 }
38360 return resultobj;
38361 fail:
38362 {
38363 if (temp3)
38364 delete arg3;
38365 }
38366 {
38367 if (temp5)
38368 delete arg5;
38369 }
38370 return NULL;
38371 }
38372
38373
38374 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38375 PyObject *resultobj = 0;
38376 wxMenu *arg1 = (wxMenu *) 0 ;
38377 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38378 wxMenuItem *result = 0 ;
38379 void *argp1 = 0 ;
38380 int res1 = 0 ;
38381 int res2 = 0 ;
38382 PyObject * obj0 = 0 ;
38383 PyObject * obj1 = 0 ;
38384 char * kwnames[] = {
38385 (char *) "self",(char *) "item", NULL
38386 };
38387
38388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38390 if (!SWIG_IsOK(res1)) {
38391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38392 }
38393 arg1 = reinterpret_cast< wxMenu * >(argp1);
38394 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38395 if (!SWIG_IsOK(res2)) {
38396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38397 }
38398 {
38399 PyThreadState* __tstate = wxPyBeginAllowThreads();
38400 result = (wxMenuItem *)(arg1)->Append(arg2);
38401 wxPyEndAllowThreads(__tstate);
38402 if (PyErr_Occurred()) SWIG_fail;
38403 }
38404 {
38405 resultobj = wxPyMake_wxObject(result, (bool)0);
38406 }
38407 return resultobj;
38408 fail:
38409 return NULL;
38410 }
38411
38412
38413 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38414 PyObject *resultobj = 0;
38415 wxMenu *arg1 = (wxMenu *) 0 ;
38416 size_t arg2 ;
38417 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38418 wxMenuItem *result = 0 ;
38419 void *argp1 = 0 ;
38420 int res1 = 0 ;
38421 size_t val2 ;
38422 int ecode2 = 0 ;
38423 int res3 = 0 ;
38424 PyObject * obj0 = 0 ;
38425 PyObject * obj1 = 0 ;
38426 PyObject * obj2 = 0 ;
38427 char * kwnames[] = {
38428 (char *) "self",(char *) "pos",(char *) "item", NULL
38429 };
38430
38431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38433 if (!SWIG_IsOK(res1)) {
38434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38435 }
38436 arg1 = reinterpret_cast< wxMenu * >(argp1);
38437 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38438 if (!SWIG_IsOK(ecode2)) {
38439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38440 }
38441 arg2 = static_cast< size_t >(val2);
38442 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38443 if (!SWIG_IsOK(res3)) {
38444 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38445 }
38446 {
38447 PyThreadState* __tstate = wxPyBeginAllowThreads();
38448 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38449 wxPyEndAllowThreads(__tstate);
38450 if (PyErr_Occurred()) SWIG_fail;
38451 }
38452 {
38453 resultobj = wxPyMake_wxObject(result, (bool)0);
38454 }
38455 return resultobj;
38456 fail:
38457 return NULL;
38458 }
38459
38460
38461 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38462 PyObject *resultobj = 0;
38463 wxMenu *arg1 = (wxMenu *) 0 ;
38464 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38465 wxMenuItem *result = 0 ;
38466 void *argp1 = 0 ;
38467 int res1 = 0 ;
38468 int res2 = 0 ;
38469 PyObject * obj0 = 0 ;
38470 PyObject * obj1 = 0 ;
38471 char * kwnames[] = {
38472 (char *) "self",(char *) "item", NULL
38473 };
38474
38475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38477 if (!SWIG_IsOK(res1)) {
38478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38479 }
38480 arg1 = reinterpret_cast< wxMenu * >(argp1);
38481 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38482 if (!SWIG_IsOK(res2)) {
38483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38484 }
38485 {
38486 PyThreadState* __tstate = wxPyBeginAllowThreads();
38487 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38488 wxPyEndAllowThreads(__tstate);
38489 if (PyErr_Occurred()) SWIG_fail;
38490 }
38491 {
38492 resultobj = wxPyMake_wxObject(result, (bool)0);
38493 }
38494 return resultobj;
38495 fail:
38496 return NULL;
38497 }
38498
38499
38500 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38501 PyObject *resultobj = 0;
38502 wxMenu *arg1 = (wxMenu *) 0 ;
38503 void *argp1 = 0 ;
38504 int res1 = 0 ;
38505 PyObject *swig_obj[1] ;
38506
38507 if (!args) SWIG_fail;
38508 swig_obj[0] = args;
38509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38510 if (!SWIG_IsOK(res1)) {
38511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38512 }
38513 arg1 = reinterpret_cast< wxMenu * >(argp1);
38514 {
38515 PyThreadState* __tstate = wxPyBeginAllowThreads();
38516 (arg1)->Break();
38517 wxPyEndAllowThreads(__tstate);
38518 if (PyErr_Occurred()) SWIG_fail;
38519 }
38520 resultobj = SWIG_Py_Void();
38521 return resultobj;
38522 fail:
38523 return NULL;
38524 }
38525
38526
38527 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38528 PyObject *resultobj = 0;
38529 wxMenu *arg1 = (wxMenu *) 0 ;
38530 size_t arg2 ;
38531 int arg3 ;
38532 wxString *arg4 = 0 ;
38533 wxString const &arg5_defvalue = wxPyEmptyString ;
38534 wxString *arg5 = (wxString *) &arg5_defvalue ;
38535 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38536 wxMenuItem *result = 0 ;
38537 void *argp1 = 0 ;
38538 int res1 = 0 ;
38539 size_t val2 ;
38540 int ecode2 = 0 ;
38541 int val3 ;
38542 int ecode3 = 0 ;
38543 bool temp4 = false ;
38544 bool temp5 = false ;
38545 int val6 ;
38546 int ecode6 = 0 ;
38547 PyObject * obj0 = 0 ;
38548 PyObject * obj1 = 0 ;
38549 PyObject * obj2 = 0 ;
38550 PyObject * obj3 = 0 ;
38551 PyObject * obj4 = 0 ;
38552 PyObject * obj5 = 0 ;
38553 char * kwnames[] = {
38554 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38555 };
38556
38557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38559 if (!SWIG_IsOK(res1)) {
38560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38561 }
38562 arg1 = reinterpret_cast< wxMenu * >(argp1);
38563 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38564 if (!SWIG_IsOK(ecode2)) {
38565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38566 }
38567 arg2 = static_cast< size_t >(val2);
38568 ecode3 = SWIG_AsVal_int(obj2, &val3);
38569 if (!SWIG_IsOK(ecode3)) {
38570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38571 }
38572 arg3 = static_cast< int >(val3);
38573 {
38574 arg4 = wxString_in_helper(obj3);
38575 if (arg4 == NULL) SWIG_fail;
38576 temp4 = true;
38577 }
38578 if (obj4) {
38579 {
38580 arg5 = wxString_in_helper(obj4);
38581 if (arg5 == NULL) SWIG_fail;
38582 temp5 = true;
38583 }
38584 }
38585 if (obj5) {
38586 ecode6 = SWIG_AsVal_int(obj5, &val6);
38587 if (!SWIG_IsOK(ecode6)) {
38588 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38589 }
38590 arg6 = static_cast< wxItemKind >(val6);
38591 }
38592 {
38593 PyThreadState* __tstate = wxPyBeginAllowThreads();
38594 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38595 wxPyEndAllowThreads(__tstate);
38596 if (PyErr_Occurred()) SWIG_fail;
38597 }
38598 {
38599 resultobj = wxPyMake_wxObject(result, (bool)0);
38600 }
38601 {
38602 if (temp4)
38603 delete arg4;
38604 }
38605 {
38606 if (temp5)
38607 delete arg5;
38608 }
38609 return resultobj;
38610 fail:
38611 {
38612 if (temp4)
38613 delete arg4;
38614 }
38615 {
38616 if (temp5)
38617 delete arg5;
38618 }
38619 return NULL;
38620 }
38621
38622
38623 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38624 PyObject *resultobj = 0;
38625 wxMenu *arg1 = (wxMenu *) 0 ;
38626 size_t arg2 ;
38627 wxMenuItem *result = 0 ;
38628 void *argp1 = 0 ;
38629 int res1 = 0 ;
38630 size_t val2 ;
38631 int ecode2 = 0 ;
38632 PyObject * obj0 = 0 ;
38633 PyObject * obj1 = 0 ;
38634 char * kwnames[] = {
38635 (char *) "self",(char *) "pos", NULL
38636 };
38637
38638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38640 if (!SWIG_IsOK(res1)) {
38641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38642 }
38643 arg1 = reinterpret_cast< wxMenu * >(argp1);
38644 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38645 if (!SWIG_IsOK(ecode2)) {
38646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38647 }
38648 arg2 = static_cast< size_t >(val2);
38649 {
38650 PyThreadState* __tstate = wxPyBeginAllowThreads();
38651 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38652 wxPyEndAllowThreads(__tstate);
38653 if (PyErr_Occurred()) SWIG_fail;
38654 }
38655 {
38656 resultobj = wxPyMake_wxObject(result, (bool)0);
38657 }
38658 return resultobj;
38659 fail:
38660 return NULL;
38661 }
38662
38663
38664 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38665 PyObject *resultobj = 0;
38666 wxMenu *arg1 = (wxMenu *) 0 ;
38667 size_t arg2 ;
38668 int arg3 ;
38669 wxString *arg4 = 0 ;
38670 wxString const &arg5_defvalue = wxPyEmptyString ;
38671 wxString *arg5 = (wxString *) &arg5_defvalue ;
38672 wxMenuItem *result = 0 ;
38673 void *argp1 = 0 ;
38674 int res1 = 0 ;
38675 size_t val2 ;
38676 int ecode2 = 0 ;
38677 int val3 ;
38678 int ecode3 = 0 ;
38679 bool temp4 = false ;
38680 bool temp5 = false ;
38681 PyObject * obj0 = 0 ;
38682 PyObject * obj1 = 0 ;
38683 PyObject * obj2 = 0 ;
38684 PyObject * obj3 = 0 ;
38685 PyObject * obj4 = 0 ;
38686 char * kwnames[] = {
38687 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38688 };
38689
38690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38692 if (!SWIG_IsOK(res1)) {
38693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38694 }
38695 arg1 = reinterpret_cast< wxMenu * >(argp1);
38696 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38697 if (!SWIG_IsOK(ecode2)) {
38698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38699 }
38700 arg2 = static_cast< size_t >(val2);
38701 ecode3 = SWIG_AsVal_int(obj2, &val3);
38702 if (!SWIG_IsOK(ecode3)) {
38703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38704 }
38705 arg3 = static_cast< int >(val3);
38706 {
38707 arg4 = wxString_in_helper(obj3);
38708 if (arg4 == NULL) SWIG_fail;
38709 temp4 = true;
38710 }
38711 if (obj4) {
38712 {
38713 arg5 = wxString_in_helper(obj4);
38714 if (arg5 == NULL) SWIG_fail;
38715 temp5 = true;
38716 }
38717 }
38718 {
38719 PyThreadState* __tstate = wxPyBeginAllowThreads();
38720 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38721 wxPyEndAllowThreads(__tstate);
38722 if (PyErr_Occurred()) SWIG_fail;
38723 }
38724 {
38725 resultobj = wxPyMake_wxObject(result, (bool)0);
38726 }
38727 {
38728 if (temp4)
38729 delete arg4;
38730 }
38731 {
38732 if (temp5)
38733 delete arg5;
38734 }
38735 return resultobj;
38736 fail:
38737 {
38738 if (temp4)
38739 delete arg4;
38740 }
38741 {
38742 if (temp5)
38743 delete arg5;
38744 }
38745 return NULL;
38746 }
38747
38748
38749 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38750 PyObject *resultobj = 0;
38751 wxMenu *arg1 = (wxMenu *) 0 ;
38752 size_t arg2 ;
38753 int arg3 ;
38754 wxString *arg4 = 0 ;
38755 wxString const &arg5_defvalue = wxPyEmptyString ;
38756 wxString *arg5 = (wxString *) &arg5_defvalue ;
38757 wxMenuItem *result = 0 ;
38758 void *argp1 = 0 ;
38759 int res1 = 0 ;
38760 size_t val2 ;
38761 int ecode2 = 0 ;
38762 int val3 ;
38763 int ecode3 = 0 ;
38764 bool temp4 = false ;
38765 bool temp5 = false ;
38766 PyObject * obj0 = 0 ;
38767 PyObject * obj1 = 0 ;
38768 PyObject * obj2 = 0 ;
38769 PyObject * obj3 = 0 ;
38770 PyObject * obj4 = 0 ;
38771 char * kwnames[] = {
38772 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38773 };
38774
38775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38777 if (!SWIG_IsOK(res1)) {
38778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38779 }
38780 arg1 = reinterpret_cast< wxMenu * >(argp1);
38781 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38782 if (!SWIG_IsOK(ecode2)) {
38783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38784 }
38785 arg2 = static_cast< size_t >(val2);
38786 ecode3 = SWIG_AsVal_int(obj2, &val3);
38787 if (!SWIG_IsOK(ecode3)) {
38788 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38789 }
38790 arg3 = static_cast< int >(val3);
38791 {
38792 arg4 = wxString_in_helper(obj3);
38793 if (arg4 == NULL) SWIG_fail;
38794 temp4 = true;
38795 }
38796 if (obj4) {
38797 {
38798 arg5 = wxString_in_helper(obj4);
38799 if (arg5 == NULL) SWIG_fail;
38800 temp5 = true;
38801 }
38802 }
38803 {
38804 PyThreadState* __tstate = wxPyBeginAllowThreads();
38805 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38806 wxPyEndAllowThreads(__tstate);
38807 if (PyErr_Occurred()) SWIG_fail;
38808 }
38809 {
38810 resultobj = wxPyMake_wxObject(result, (bool)0);
38811 }
38812 {
38813 if (temp4)
38814 delete arg4;
38815 }
38816 {
38817 if (temp5)
38818 delete arg5;
38819 }
38820 return resultobj;
38821 fail:
38822 {
38823 if (temp4)
38824 delete arg4;
38825 }
38826 {
38827 if (temp5)
38828 delete arg5;
38829 }
38830 return NULL;
38831 }
38832
38833
38834 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38835 PyObject *resultobj = 0;
38836 wxMenu *arg1 = (wxMenu *) 0 ;
38837 size_t arg2 ;
38838 int arg3 ;
38839 wxString *arg4 = 0 ;
38840 wxMenu *arg5 = (wxMenu *) 0 ;
38841 wxString const &arg6_defvalue = wxPyEmptyString ;
38842 wxString *arg6 = (wxString *) &arg6_defvalue ;
38843 wxMenuItem *result = 0 ;
38844 void *argp1 = 0 ;
38845 int res1 = 0 ;
38846 size_t val2 ;
38847 int ecode2 = 0 ;
38848 int val3 ;
38849 int ecode3 = 0 ;
38850 bool temp4 = false ;
38851 void *argp5 = 0 ;
38852 int res5 = 0 ;
38853 bool temp6 = false ;
38854 PyObject * obj0 = 0 ;
38855 PyObject * obj1 = 0 ;
38856 PyObject * obj2 = 0 ;
38857 PyObject * obj3 = 0 ;
38858 PyObject * obj4 = 0 ;
38859 PyObject * obj5 = 0 ;
38860 char * kwnames[] = {
38861 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38862 };
38863
38864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38866 if (!SWIG_IsOK(res1)) {
38867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38868 }
38869 arg1 = reinterpret_cast< wxMenu * >(argp1);
38870 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38871 if (!SWIG_IsOK(ecode2)) {
38872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38873 }
38874 arg2 = static_cast< size_t >(val2);
38875 ecode3 = SWIG_AsVal_int(obj2, &val3);
38876 if (!SWIG_IsOK(ecode3)) {
38877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38878 }
38879 arg3 = static_cast< int >(val3);
38880 {
38881 arg4 = wxString_in_helper(obj3);
38882 if (arg4 == NULL) SWIG_fail;
38883 temp4 = true;
38884 }
38885 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
38886 if (!SWIG_IsOK(res5)) {
38887 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
38888 }
38889 arg5 = reinterpret_cast< wxMenu * >(argp5);
38890 if (obj5) {
38891 {
38892 arg6 = wxString_in_helper(obj5);
38893 if (arg6 == NULL) SWIG_fail;
38894 temp6 = true;
38895 }
38896 }
38897 {
38898 PyThreadState* __tstate = wxPyBeginAllowThreads();
38899 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
38900 wxPyEndAllowThreads(__tstate);
38901 if (PyErr_Occurred()) SWIG_fail;
38902 }
38903 {
38904 resultobj = wxPyMake_wxObject(result, (bool)0);
38905 }
38906 {
38907 if (temp4)
38908 delete arg4;
38909 }
38910 {
38911 if (temp6)
38912 delete arg6;
38913 }
38914 return resultobj;
38915 fail:
38916 {
38917 if (temp4)
38918 delete arg4;
38919 }
38920 {
38921 if (temp6)
38922 delete arg6;
38923 }
38924 return NULL;
38925 }
38926
38927
38928 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38929 PyObject *resultobj = 0;
38930 wxMenu *arg1 = (wxMenu *) 0 ;
38931 int arg2 ;
38932 wxString *arg3 = 0 ;
38933 wxString const &arg4_defvalue = wxPyEmptyString ;
38934 wxString *arg4 = (wxString *) &arg4_defvalue ;
38935 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38936 wxMenuItem *result = 0 ;
38937 void *argp1 = 0 ;
38938 int res1 = 0 ;
38939 int val2 ;
38940 int ecode2 = 0 ;
38941 bool temp3 = false ;
38942 bool temp4 = false ;
38943 int val5 ;
38944 int ecode5 = 0 ;
38945 PyObject * obj0 = 0 ;
38946 PyObject * obj1 = 0 ;
38947 PyObject * obj2 = 0 ;
38948 PyObject * obj3 = 0 ;
38949 PyObject * obj4 = 0 ;
38950 char * kwnames[] = {
38951 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38952 };
38953
38954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38956 if (!SWIG_IsOK(res1)) {
38957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
38958 }
38959 arg1 = reinterpret_cast< wxMenu * >(argp1);
38960 ecode2 = SWIG_AsVal_int(obj1, &val2);
38961 if (!SWIG_IsOK(ecode2)) {
38962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
38963 }
38964 arg2 = static_cast< int >(val2);
38965 {
38966 arg3 = wxString_in_helper(obj2);
38967 if (arg3 == NULL) SWIG_fail;
38968 temp3 = true;
38969 }
38970 if (obj3) {
38971 {
38972 arg4 = wxString_in_helper(obj3);
38973 if (arg4 == NULL) SWIG_fail;
38974 temp4 = true;
38975 }
38976 }
38977 if (obj4) {
38978 ecode5 = SWIG_AsVal_int(obj4, &val5);
38979 if (!SWIG_IsOK(ecode5)) {
38980 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
38981 }
38982 arg5 = static_cast< wxItemKind >(val5);
38983 }
38984 {
38985 PyThreadState* __tstate = wxPyBeginAllowThreads();
38986 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38987 wxPyEndAllowThreads(__tstate);
38988 if (PyErr_Occurred()) SWIG_fail;
38989 }
38990 {
38991 resultobj = wxPyMake_wxObject(result, (bool)0);
38992 }
38993 {
38994 if (temp3)
38995 delete arg3;
38996 }
38997 {
38998 if (temp4)
38999 delete arg4;
39000 }
39001 return resultobj;
39002 fail:
39003 {
39004 if (temp3)
39005 delete arg3;
39006 }
39007 {
39008 if (temp4)
39009 delete arg4;
39010 }
39011 return NULL;
39012 }
39013
39014
39015 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39016 PyObject *resultobj = 0;
39017 wxMenu *arg1 = (wxMenu *) 0 ;
39018 wxMenuItem *result = 0 ;
39019 void *argp1 = 0 ;
39020 int res1 = 0 ;
39021 PyObject *swig_obj[1] ;
39022
39023 if (!args) SWIG_fail;
39024 swig_obj[0] = args;
39025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39026 if (!SWIG_IsOK(res1)) {
39027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39028 }
39029 arg1 = reinterpret_cast< wxMenu * >(argp1);
39030 {
39031 PyThreadState* __tstate = wxPyBeginAllowThreads();
39032 result = (wxMenuItem *)(arg1)->PrependSeparator();
39033 wxPyEndAllowThreads(__tstate);
39034 if (PyErr_Occurred()) SWIG_fail;
39035 }
39036 {
39037 resultobj = wxPyMake_wxObject(result, (bool)0);
39038 }
39039 return resultobj;
39040 fail:
39041 return NULL;
39042 }
39043
39044
39045 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39046 PyObject *resultobj = 0;
39047 wxMenu *arg1 = (wxMenu *) 0 ;
39048 int arg2 ;
39049 wxString *arg3 = 0 ;
39050 wxString const &arg4_defvalue = wxPyEmptyString ;
39051 wxString *arg4 = (wxString *) &arg4_defvalue ;
39052 wxMenuItem *result = 0 ;
39053 void *argp1 = 0 ;
39054 int res1 = 0 ;
39055 int val2 ;
39056 int ecode2 = 0 ;
39057 bool temp3 = false ;
39058 bool temp4 = false ;
39059 PyObject * obj0 = 0 ;
39060 PyObject * obj1 = 0 ;
39061 PyObject * obj2 = 0 ;
39062 PyObject * obj3 = 0 ;
39063 char * kwnames[] = {
39064 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39065 };
39066
39067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39069 if (!SWIG_IsOK(res1)) {
39070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39071 }
39072 arg1 = reinterpret_cast< wxMenu * >(argp1);
39073 ecode2 = SWIG_AsVal_int(obj1, &val2);
39074 if (!SWIG_IsOK(ecode2)) {
39075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39076 }
39077 arg2 = static_cast< int >(val2);
39078 {
39079 arg3 = wxString_in_helper(obj2);
39080 if (arg3 == NULL) SWIG_fail;
39081 temp3 = true;
39082 }
39083 if (obj3) {
39084 {
39085 arg4 = wxString_in_helper(obj3);
39086 if (arg4 == NULL) SWIG_fail;
39087 temp4 = true;
39088 }
39089 }
39090 {
39091 PyThreadState* __tstate = wxPyBeginAllowThreads();
39092 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39093 wxPyEndAllowThreads(__tstate);
39094 if (PyErr_Occurred()) SWIG_fail;
39095 }
39096 {
39097 resultobj = wxPyMake_wxObject(result, (bool)0);
39098 }
39099 {
39100 if (temp3)
39101 delete arg3;
39102 }
39103 {
39104 if (temp4)
39105 delete arg4;
39106 }
39107 return resultobj;
39108 fail:
39109 {
39110 if (temp3)
39111 delete arg3;
39112 }
39113 {
39114 if (temp4)
39115 delete arg4;
39116 }
39117 return NULL;
39118 }
39119
39120
39121 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39122 PyObject *resultobj = 0;
39123 wxMenu *arg1 = (wxMenu *) 0 ;
39124 int arg2 ;
39125 wxString *arg3 = 0 ;
39126 wxString const &arg4_defvalue = wxPyEmptyString ;
39127 wxString *arg4 = (wxString *) &arg4_defvalue ;
39128 wxMenuItem *result = 0 ;
39129 void *argp1 = 0 ;
39130 int res1 = 0 ;
39131 int val2 ;
39132 int ecode2 = 0 ;
39133 bool temp3 = false ;
39134 bool temp4 = false ;
39135 PyObject * obj0 = 0 ;
39136 PyObject * obj1 = 0 ;
39137 PyObject * obj2 = 0 ;
39138 PyObject * obj3 = 0 ;
39139 char * kwnames[] = {
39140 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39141 };
39142
39143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39145 if (!SWIG_IsOK(res1)) {
39146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39147 }
39148 arg1 = reinterpret_cast< wxMenu * >(argp1);
39149 ecode2 = SWIG_AsVal_int(obj1, &val2);
39150 if (!SWIG_IsOK(ecode2)) {
39151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39152 }
39153 arg2 = static_cast< int >(val2);
39154 {
39155 arg3 = wxString_in_helper(obj2);
39156 if (arg3 == NULL) SWIG_fail;
39157 temp3 = true;
39158 }
39159 if (obj3) {
39160 {
39161 arg4 = wxString_in_helper(obj3);
39162 if (arg4 == NULL) SWIG_fail;
39163 temp4 = true;
39164 }
39165 }
39166 {
39167 PyThreadState* __tstate = wxPyBeginAllowThreads();
39168 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39169 wxPyEndAllowThreads(__tstate);
39170 if (PyErr_Occurred()) SWIG_fail;
39171 }
39172 {
39173 resultobj = wxPyMake_wxObject(result, (bool)0);
39174 }
39175 {
39176 if (temp3)
39177 delete arg3;
39178 }
39179 {
39180 if (temp4)
39181 delete arg4;
39182 }
39183 return resultobj;
39184 fail:
39185 {
39186 if (temp3)
39187 delete arg3;
39188 }
39189 {
39190 if (temp4)
39191 delete arg4;
39192 }
39193 return NULL;
39194 }
39195
39196
39197 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39198 PyObject *resultobj = 0;
39199 wxMenu *arg1 = (wxMenu *) 0 ;
39200 int arg2 ;
39201 wxString *arg3 = 0 ;
39202 wxMenu *arg4 = (wxMenu *) 0 ;
39203 wxString const &arg5_defvalue = wxPyEmptyString ;
39204 wxString *arg5 = (wxString *) &arg5_defvalue ;
39205 wxMenuItem *result = 0 ;
39206 void *argp1 = 0 ;
39207 int res1 = 0 ;
39208 int val2 ;
39209 int ecode2 = 0 ;
39210 bool temp3 = false ;
39211 void *argp4 = 0 ;
39212 int res4 = 0 ;
39213 bool temp5 = false ;
39214 PyObject * obj0 = 0 ;
39215 PyObject * obj1 = 0 ;
39216 PyObject * obj2 = 0 ;
39217 PyObject * obj3 = 0 ;
39218 PyObject * obj4 = 0 ;
39219 char * kwnames[] = {
39220 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39221 };
39222
39223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39225 if (!SWIG_IsOK(res1)) {
39226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39227 }
39228 arg1 = reinterpret_cast< wxMenu * >(argp1);
39229 ecode2 = SWIG_AsVal_int(obj1, &val2);
39230 if (!SWIG_IsOK(ecode2)) {
39231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39232 }
39233 arg2 = static_cast< int >(val2);
39234 {
39235 arg3 = wxString_in_helper(obj2);
39236 if (arg3 == NULL) SWIG_fail;
39237 temp3 = true;
39238 }
39239 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39240 if (!SWIG_IsOK(res4)) {
39241 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39242 }
39243 arg4 = reinterpret_cast< wxMenu * >(argp4);
39244 if (obj4) {
39245 {
39246 arg5 = wxString_in_helper(obj4);
39247 if (arg5 == NULL) SWIG_fail;
39248 temp5 = true;
39249 }
39250 }
39251 {
39252 PyThreadState* __tstate = wxPyBeginAllowThreads();
39253 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39254 wxPyEndAllowThreads(__tstate);
39255 if (PyErr_Occurred()) SWIG_fail;
39256 }
39257 {
39258 resultobj = wxPyMake_wxObject(result, (bool)0);
39259 }
39260 {
39261 if (temp3)
39262 delete arg3;
39263 }
39264 {
39265 if (temp5)
39266 delete arg5;
39267 }
39268 return resultobj;
39269 fail:
39270 {
39271 if (temp3)
39272 delete arg3;
39273 }
39274 {
39275 if (temp5)
39276 delete arg5;
39277 }
39278 return NULL;
39279 }
39280
39281
39282 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39283 PyObject *resultobj = 0;
39284 wxMenu *arg1 = (wxMenu *) 0 ;
39285 int arg2 ;
39286 wxMenuItem *result = 0 ;
39287 void *argp1 = 0 ;
39288 int res1 = 0 ;
39289 int val2 ;
39290 int ecode2 = 0 ;
39291 PyObject * obj0 = 0 ;
39292 PyObject * obj1 = 0 ;
39293 char * kwnames[] = {
39294 (char *) "self",(char *) "id", NULL
39295 };
39296
39297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39299 if (!SWIG_IsOK(res1)) {
39300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39301 }
39302 arg1 = reinterpret_cast< wxMenu * >(argp1);
39303 ecode2 = SWIG_AsVal_int(obj1, &val2);
39304 if (!SWIG_IsOK(ecode2)) {
39305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39306 }
39307 arg2 = static_cast< int >(val2);
39308 {
39309 PyThreadState* __tstate = wxPyBeginAllowThreads();
39310 result = (wxMenuItem *)(arg1)->Remove(arg2);
39311 wxPyEndAllowThreads(__tstate);
39312 if (PyErr_Occurred()) SWIG_fail;
39313 }
39314 {
39315 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39316 }
39317 return resultobj;
39318 fail:
39319 return NULL;
39320 }
39321
39322
39323 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39324 PyObject *resultobj = 0;
39325 wxMenu *arg1 = (wxMenu *) 0 ;
39326 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39327 wxMenuItem *result = 0 ;
39328 void *argp1 = 0 ;
39329 int res1 = 0 ;
39330 void *argp2 = 0 ;
39331 int res2 = 0 ;
39332 PyObject * obj0 = 0 ;
39333 PyObject * obj1 = 0 ;
39334 char * kwnames[] = {
39335 (char *) "self",(char *) "item", NULL
39336 };
39337
39338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39340 if (!SWIG_IsOK(res1)) {
39341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39342 }
39343 arg1 = reinterpret_cast< wxMenu * >(argp1);
39344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39345 if (!SWIG_IsOK(res2)) {
39346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39347 }
39348 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39349 {
39350 PyThreadState* __tstate = wxPyBeginAllowThreads();
39351 result = (wxMenuItem *)(arg1)->Remove(arg2);
39352 wxPyEndAllowThreads(__tstate);
39353 if (PyErr_Occurred()) SWIG_fail;
39354 }
39355 {
39356 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39357 }
39358 return resultobj;
39359 fail:
39360 return NULL;
39361 }
39362
39363
39364 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39365 PyObject *resultobj = 0;
39366 wxMenu *arg1 = (wxMenu *) 0 ;
39367 int arg2 ;
39368 bool result;
39369 void *argp1 = 0 ;
39370 int res1 = 0 ;
39371 int val2 ;
39372 int ecode2 = 0 ;
39373 PyObject * obj0 = 0 ;
39374 PyObject * obj1 = 0 ;
39375 char * kwnames[] = {
39376 (char *) "self",(char *) "id", NULL
39377 };
39378
39379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39381 if (!SWIG_IsOK(res1)) {
39382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39383 }
39384 arg1 = reinterpret_cast< wxMenu * >(argp1);
39385 ecode2 = SWIG_AsVal_int(obj1, &val2);
39386 if (!SWIG_IsOK(ecode2)) {
39387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39388 }
39389 arg2 = static_cast< int >(val2);
39390 {
39391 PyThreadState* __tstate = wxPyBeginAllowThreads();
39392 result = (bool)(arg1)->Delete(arg2);
39393 wxPyEndAllowThreads(__tstate);
39394 if (PyErr_Occurred()) SWIG_fail;
39395 }
39396 {
39397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39398 }
39399 return resultobj;
39400 fail:
39401 return NULL;
39402 }
39403
39404
39405 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39406 PyObject *resultobj = 0;
39407 wxMenu *arg1 = (wxMenu *) 0 ;
39408 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39409 bool result;
39410 void *argp1 = 0 ;
39411 int res1 = 0 ;
39412 void *argp2 = 0 ;
39413 int res2 = 0 ;
39414 PyObject * obj0 = 0 ;
39415 PyObject * obj1 = 0 ;
39416 char * kwnames[] = {
39417 (char *) "self",(char *) "item", NULL
39418 };
39419
39420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39422 if (!SWIG_IsOK(res1)) {
39423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39424 }
39425 arg1 = reinterpret_cast< wxMenu * >(argp1);
39426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39427 if (!SWIG_IsOK(res2)) {
39428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39429 }
39430 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39431 {
39432 PyThreadState* __tstate = wxPyBeginAllowThreads();
39433 result = (bool)(arg1)->Delete(arg2);
39434 wxPyEndAllowThreads(__tstate);
39435 if (PyErr_Occurred()) SWIG_fail;
39436 }
39437 {
39438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39439 }
39440 return resultobj;
39441 fail:
39442 return NULL;
39443 }
39444
39445
39446 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39447 PyObject *resultobj = 0;
39448 wxMenu *arg1 = (wxMenu *) 0 ;
39449 void *argp1 = 0 ;
39450 int res1 = 0 ;
39451 PyObject *swig_obj[1] ;
39452
39453 if (!args) SWIG_fail;
39454 swig_obj[0] = args;
39455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39456 if (!SWIG_IsOK(res1)) {
39457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39458 }
39459 arg1 = reinterpret_cast< wxMenu * >(argp1);
39460 {
39461 PyThreadState* __tstate = wxPyBeginAllowThreads();
39462 wxMenu_Destroy(arg1);
39463 wxPyEndAllowThreads(__tstate);
39464 if (PyErr_Occurred()) SWIG_fail;
39465 }
39466 resultobj = SWIG_Py_Void();
39467 return resultobj;
39468 fail:
39469 return NULL;
39470 }
39471
39472
39473 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39474 PyObject *resultobj = 0;
39475 wxMenu *arg1 = (wxMenu *) 0 ;
39476 int arg2 ;
39477 bool result;
39478 void *argp1 = 0 ;
39479 int res1 = 0 ;
39480 int val2 ;
39481 int ecode2 = 0 ;
39482 PyObject * obj0 = 0 ;
39483 PyObject * obj1 = 0 ;
39484 char * kwnames[] = {
39485 (char *) "self",(char *) "id", NULL
39486 };
39487
39488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39490 if (!SWIG_IsOK(res1)) {
39491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39492 }
39493 arg1 = reinterpret_cast< wxMenu * >(argp1);
39494 ecode2 = SWIG_AsVal_int(obj1, &val2);
39495 if (!SWIG_IsOK(ecode2)) {
39496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39497 }
39498 arg2 = static_cast< int >(val2);
39499 {
39500 PyThreadState* __tstate = wxPyBeginAllowThreads();
39501 result = (bool)(arg1)->Destroy(arg2);
39502 wxPyEndAllowThreads(__tstate);
39503 if (PyErr_Occurred()) SWIG_fail;
39504 }
39505 {
39506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39507 }
39508 return resultobj;
39509 fail:
39510 return NULL;
39511 }
39512
39513
39514 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39515 PyObject *resultobj = 0;
39516 wxMenu *arg1 = (wxMenu *) 0 ;
39517 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39518 bool result;
39519 void *argp1 = 0 ;
39520 int res1 = 0 ;
39521 void *argp2 = 0 ;
39522 int res2 = 0 ;
39523 PyObject * obj0 = 0 ;
39524 PyObject * obj1 = 0 ;
39525 char * kwnames[] = {
39526 (char *) "self",(char *) "item", NULL
39527 };
39528
39529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39531 if (!SWIG_IsOK(res1)) {
39532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39533 }
39534 arg1 = reinterpret_cast< wxMenu * >(argp1);
39535 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39536 if (!SWIG_IsOK(res2)) {
39537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39538 }
39539 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39540 {
39541 PyThreadState* __tstate = wxPyBeginAllowThreads();
39542 result = (bool)(arg1)->Destroy(arg2);
39543 wxPyEndAllowThreads(__tstate);
39544 if (PyErr_Occurred()) SWIG_fail;
39545 }
39546 {
39547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39548 }
39549 return resultobj;
39550 fail:
39551 return NULL;
39552 }
39553
39554
39555 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39556 PyObject *resultobj = 0;
39557 wxMenu *arg1 = (wxMenu *) 0 ;
39558 size_t result;
39559 void *argp1 = 0 ;
39560 int res1 = 0 ;
39561 PyObject *swig_obj[1] ;
39562
39563 if (!args) SWIG_fail;
39564 swig_obj[0] = args;
39565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39566 if (!SWIG_IsOK(res1)) {
39567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39568 }
39569 arg1 = reinterpret_cast< wxMenu * >(argp1);
39570 {
39571 PyThreadState* __tstate = wxPyBeginAllowThreads();
39572 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39573 wxPyEndAllowThreads(__tstate);
39574 if (PyErr_Occurred()) SWIG_fail;
39575 }
39576 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39577 return resultobj;
39578 fail:
39579 return NULL;
39580 }
39581
39582
39583 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39584 PyObject *resultobj = 0;
39585 wxMenu *arg1 = (wxMenu *) 0 ;
39586 PyObject *result = 0 ;
39587 void *argp1 = 0 ;
39588 int res1 = 0 ;
39589 PyObject *swig_obj[1] ;
39590
39591 if (!args) SWIG_fail;
39592 swig_obj[0] = args;
39593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39594 if (!SWIG_IsOK(res1)) {
39595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39596 }
39597 arg1 = reinterpret_cast< wxMenu * >(argp1);
39598 {
39599 PyThreadState* __tstate = wxPyBeginAllowThreads();
39600 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39601 wxPyEndAllowThreads(__tstate);
39602 if (PyErr_Occurred()) SWIG_fail;
39603 }
39604 resultobj = result;
39605 return resultobj;
39606 fail:
39607 return NULL;
39608 }
39609
39610
39611 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39612 PyObject *resultobj = 0;
39613 wxMenu *arg1 = (wxMenu *) 0 ;
39614 wxString *arg2 = 0 ;
39615 int result;
39616 void *argp1 = 0 ;
39617 int res1 = 0 ;
39618 bool temp2 = false ;
39619 PyObject * obj0 = 0 ;
39620 PyObject * obj1 = 0 ;
39621 char * kwnames[] = {
39622 (char *) "self",(char *) "item", NULL
39623 };
39624
39625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39627 if (!SWIG_IsOK(res1)) {
39628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39629 }
39630 arg1 = reinterpret_cast< wxMenu * >(argp1);
39631 {
39632 arg2 = wxString_in_helper(obj1);
39633 if (arg2 == NULL) SWIG_fail;
39634 temp2 = true;
39635 }
39636 {
39637 PyThreadState* __tstate = wxPyBeginAllowThreads();
39638 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39639 wxPyEndAllowThreads(__tstate);
39640 if (PyErr_Occurred()) SWIG_fail;
39641 }
39642 resultobj = SWIG_From_int(static_cast< int >(result));
39643 {
39644 if (temp2)
39645 delete arg2;
39646 }
39647 return resultobj;
39648 fail:
39649 {
39650 if (temp2)
39651 delete arg2;
39652 }
39653 return NULL;
39654 }
39655
39656
39657 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39658 PyObject *resultobj = 0;
39659 wxMenu *arg1 = (wxMenu *) 0 ;
39660 int arg2 ;
39661 wxMenuItem *result = 0 ;
39662 void *argp1 = 0 ;
39663 int res1 = 0 ;
39664 int val2 ;
39665 int ecode2 = 0 ;
39666 PyObject * obj0 = 0 ;
39667 PyObject * obj1 = 0 ;
39668 char * kwnames[] = {
39669 (char *) "self",(char *) "id", NULL
39670 };
39671
39672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39674 if (!SWIG_IsOK(res1)) {
39675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39676 }
39677 arg1 = reinterpret_cast< wxMenu * >(argp1);
39678 ecode2 = SWIG_AsVal_int(obj1, &val2);
39679 if (!SWIG_IsOK(ecode2)) {
39680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39681 }
39682 arg2 = static_cast< int >(val2);
39683 {
39684 PyThreadState* __tstate = wxPyBeginAllowThreads();
39685 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39686 wxPyEndAllowThreads(__tstate);
39687 if (PyErr_Occurred()) SWIG_fail;
39688 }
39689 {
39690 resultobj = wxPyMake_wxObject(result, (bool)0);
39691 }
39692 return resultobj;
39693 fail:
39694 return NULL;
39695 }
39696
39697
39698 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39699 PyObject *resultobj = 0;
39700 wxMenu *arg1 = (wxMenu *) 0 ;
39701 size_t arg2 ;
39702 wxMenuItem *result = 0 ;
39703 void *argp1 = 0 ;
39704 int res1 = 0 ;
39705 size_t val2 ;
39706 int ecode2 = 0 ;
39707 PyObject * obj0 = 0 ;
39708 PyObject * obj1 = 0 ;
39709 char * kwnames[] = {
39710 (char *) "self",(char *) "position", NULL
39711 };
39712
39713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39715 if (!SWIG_IsOK(res1)) {
39716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39717 }
39718 arg1 = reinterpret_cast< wxMenu * >(argp1);
39719 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39720 if (!SWIG_IsOK(ecode2)) {
39721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39722 }
39723 arg2 = static_cast< size_t >(val2);
39724 {
39725 PyThreadState* __tstate = wxPyBeginAllowThreads();
39726 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39727 wxPyEndAllowThreads(__tstate);
39728 if (PyErr_Occurred()) SWIG_fail;
39729 }
39730 {
39731 resultobj = wxPyMake_wxObject(result, (bool)0);
39732 }
39733 return resultobj;
39734 fail:
39735 return NULL;
39736 }
39737
39738
39739 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39740 PyObject *resultobj = 0;
39741 wxMenu *arg1 = (wxMenu *) 0 ;
39742 int arg2 ;
39743 bool arg3 ;
39744 void *argp1 = 0 ;
39745 int res1 = 0 ;
39746 int val2 ;
39747 int ecode2 = 0 ;
39748 bool val3 ;
39749 int ecode3 = 0 ;
39750 PyObject * obj0 = 0 ;
39751 PyObject * obj1 = 0 ;
39752 PyObject * obj2 = 0 ;
39753 char * kwnames[] = {
39754 (char *) "self",(char *) "id",(char *) "enable", NULL
39755 };
39756
39757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39759 if (!SWIG_IsOK(res1)) {
39760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39761 }
39762 arg1 = reinterpret_cast< wxMenu * >(argp1);
39763 ecode2 = SWIG_AsVal_int(obj1, &val2);
39764 if (!SWIG_IsOK(ecode2)) {
39765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39766 }
39767 arg2 = static_cast< int >(val2);
39768 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39769 if (!SWIG_IsOK(ecode3)) {
39770 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39771 }
39772 arg3 = static_cast< bool >(val3);
39773 {
39774 PyThreadState* __tstate = wxPyBeginAllowThreads();
39775 (arg1)->Enable(arg2,arg3);
39776 wxPyEndAllowThreads(__tstate);
39777 if (PyErr_Occurred()) SWIG_fail;
39778 }
39779 resultobj = SWIG_Py_Void();
39780 return resultobj;
39781 fail:
39782 return NULL;
39783 }
39784
39785
39786 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39787 PyObject *resultobj = 0;
39788 wxMenu *arg1 = (wxMenu *) 0 ;
39789 int arg2 ;
39790 bool result;
39791 void *argp1 = 0 ;
39792 int res1 = 0 ;
39793 int val2 ;
39794 int ecode2 = 0 ;
39795 PyObject * obj0 = 0 ;
39796 PyObject * obj1 = 0 ;
39797 char * kwnames[] = {
39798 (char *) "self",(char *) "id", NULL
39799 };
39800
39801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39803 if (!SWIG_IsOK(res1)) {
39804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39805 }
39806 arg1 = reinterpret_cast< wxMenu * >(argp1);
39807 ecode2 = SWIG_AsVal_int(obj1, &val2);
39808 if (!SWIG_IsOK(ecode2)) {
39809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39810 }
39811 arg2 = static_cast< int >(val2);
39812 {
39813 PyThreadState* __tstate = wxPyBeginAllowThreads();
39814 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39815 wxPyEndAllowThreads(__tstate);
39816 if (PyErr_Occurred()) SWIG_fail;
39817 }
39818 {
39819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39820 }
39821 return resultobj;
39822 fail:
39823 return NULL;
39824 }
39825
39826
39827 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39828 PyObject *resultobj = 0;
39829 wxMenu *arg1 = (wxMenu *) 0 ;
39830 int arg2 ;
39831 bool arg3 ;
39832 void *argp1 = 0 ;
39833 int res1 = 0 ;
39834 int val2 ;
39835 int ecode2 = 0 ;
39836 bool val3 ;
39837 int ecode3 = 0 ;
39838 PyObject * obj0 = 0 ;
39839 PyObject * obj1 = 0 ;
39840 PyObject * obj2 = 0 ;
39841 char * kwnames[] = {
39842 (char *) "self",(char *) "id",(char *) "check", NULL
39843 };
39844
39845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39847 if (!SWIG_IsOK(res1)) {
39848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39849 }
39850 arg1 = reinterpret_cast< wxMenu * >(argp1);
39851 ecode2 = SWIG_AsVal_int(obj1, &val2);
39852 if (!SWIG_IsOK(ecode2)) {
39853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39854 }
39855 arg2 = static_cast< int >(val2);
39856 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39857 if (!SWIG_IsOK(ecode3)) {
39858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39859 }
39860 arg3 = static_cast< bool >(val3);
39861 {
39862 PyThreadState* __tstate = wxPyBeginAllowThreads();
39863 (arg1)->Check(arg2,arg3);
39864 wxPyEndAllowThreads(__tstate);
39865 if (PyErr_Occurred()) SWIG_fail;
39866 }
39867 resultobj = SWIG_Py_Void();
39868 return resultobj;
39869 fail:
39870 return NULL;
39871 }
39872
39873
39874 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39875 PyObject *resultobj = 0;
39876 wxMenu *arg1 = (wxMenu *) 0 ;
39877 int arg2 ;
39878 bool result;
39879 void *argp1 = 0 ;
39880 int res1 = 0 ;
39881 int val2 ;
39882 int ecode2 = 0 ;
39883 PyObject * obj0 = 0 ;
39884 PyObject * obj1 = 0 ;
39885 char * kwnames[] = {
39886 (char *) "self",(char *) "id", NULL
39887 };
39888
39889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
39890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39891 if (!SWIG_IsOK(res1)) {
39892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
39893 }
39894 arg1 = reinterpret_cast< wxMenu * >(argp1);
39895 ecode2 = SWIG_AsVal_int(obj1, &val2);
39896 if (!SWIG_IsOK(ecode2)) {
39897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
39898 }
39899 arg2 = static_cast< int >(val2);
39900 {
39901 PyThreadState* __tstate = wxPyBeginAllowThreads();
39902 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
39903 wxPyEndAllowThreads(__tstate);
39904 if (PyErr_Occurred()) SWIG_fail;
39905 }
39906 {
39907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39908 }
39909 return resultobj;
39910 fail:
39911 return NULL;
39912 }
39913
39914
39915 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39916 PyObject *resultobj = 0;
39917 wxMenu *arg1 = (wxMenu *) 0 ;
39918 int arg2 ;
39919 wxString *arg3 = 0 ;
39920 void *argp1 = 0 ;
39921 int res1 = 0 ;
39922 int val2 ;
39923 int ecode2 = 0 ;
39924 bool temp3 = false ;
39925 PyObject * obj0 = 0 ;
39926 PyObject * obj1 = 0 ;
39927 PyObject * obj2 = 0 ;
39928 char * kwnames[] = {
39929 (char *) "self",(char *) "id",(char *) "label", NULL
39930 };
39931
39932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39934 if (!SWIG_IsOK(res1)) {
39935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
39936 }
39937 arg1 = reinterpret_cast< wxMenu * >(argp1);
39938 ecode2 = SWIG_AsVal_int(obj1, &val2);
39939 if (!SWIG_IsOK(ecode2)) {
39940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
39941 }
39942 arg2 = static_cast< int >(val2);
39943 {
39944 arg3 = wxString_in_helper(obj2);
39945 if (arg3 == NULL) SWIG_fail;
39946 temp3 = true;
39947 }
39948 {
39949 PyThreadState* __tstate = wxPyBeginAllowThreads();
39950 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
39951 wxPyEndAllowThreads(__tstate);
39952 if (PyErr_Occurred()) SWIG_fail;
39953 }
39954 resultobj = SWIG_Py_Void();
39955 {
39956 if (temp3)
39957 delete arg3;
39958 }
39959 return resultobj;
39960 fail:
39961 {
39962 if (temp3)
39963 delete arg3;
39964 }
39965 return NULL;
39966 }
39967
39968
39969 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39970 PyObject *resultobj = 0;
39971 wxMenu *arg1 = (wxMenu *) 0 ;
39972 int arg2 ;
39973 wxString result;
39974 void *argp1 = 0 ;
39975 int res1 = 0 ;
39976 int val2 ;
39977 int ecode2 = 0 ;
39978 PyObject * obj0 = 0 ;
39979 PyObject * obj1 = 0 ;
39980 char * kwnames[] = {
39981 (char *) "self",(char *) "id", NULL
39982 };
39983
39984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39986 if (!SWIG_IsOK(res1)) {
39987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
39988 }
39989 arg1 = reinterpret_cast< wxMenu * >(argp1);
39990 ecode2 = SWIG_AsVal_int(obj1, &val2);
39991 if (!SWIG_IsOK(ecode2)) {
39992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
39993 }
39994 arg2 = static_cast< int >(val2);
39995 {
39996 PyThreadState* __tstate = wxPyBeginAllowThreads();
39997 result = ((wxMenu const *)arg1)->GetLabel(arg2);
39998 wxPyEndAllowThreads(__tstate);
39999 if (PyErr_Occurred()) SWIG_fail;
40000 }
40001 {
40002 #if wxUSE_UNICODE
40003 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40004 #else
40005 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40006 #endif
40007 }
40008 return resultobj;
40009 fail:
40010 return NULL;
40011 }
40012
40013
40014 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40015 PyObject *resultobj = 0;
40016 wxMenu *arg1 = (wxMenu *) 0 ;
40017 int arg2 ;
40018 wxString *arg3 = 0 ;
40019 void *argp1 = 0 ;
40020 int res1 = 0 ;
40021 int val2 ;
40022 int ecode2 = 0 ;
40023 bool temp3 = false ;
40024 PyObject * obj0 = 0 ;
40025 PyObject * obj1 = 0 ;
40026 PyObject * obj2 = 0 ;
40027 char * kwnames[] = {
40028 (char *) "self",(char *) "id",(char *) "helpString", NULL
40029 };
40030
40031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40033 if (!SWIG_IsOK(res1)) {
40034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40035 }
40036 arg1 = reinterpret_cast< wxMenu * >(argp1);
40037 ecode2 = SWIG_AsVal_int(obj1, &val2);
40038 if (!SWIG_IsOK(ecode2)) {
40039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40040 }
40041 arg2 = static_cast< int >(val2);
40042 {
40043 arg3 = wxString_in_helper(obj2);
40044 if (arg3 == NULL) SWIG_fail;
40045 temp3 = true;
40046 }
40047 {
40048 PyThreadState* __tstate = wxPyBeginAllowThreads();
40049 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40050 wxPyEndAllowThreads(__tstate);
40051 if (PyErr_Occurred()) SWIG_fail;
40052 }
40053 resultobj = SWIG_Py_Void();
40054 {
40055 if (temp3)
40056 delete arg3;
40057 }
40058 return resultobj;
40059 fail:
40060 {
40061 if (temp3)
40062 delete arg3;
40063 }
40064 return NULL;
40065 }
40066
40067
40068 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40069 PyObject *resultobj = 0;
40070 wxMenu *arg1 = (wxMenu *) 0 ;
40071 int arg2 ;
40072 wxString result;
40073 void *argp1 = 0 ;
40074 int res1 = 0 ;
40075 int val2 ;
40076 int ecode2 = 0 ;
40077 PyObject * obj0 = 0 ;
40078 PyObject * obj1 = 0 ;
40079 char * kwnames[] = {
40080 (char *) "self",(char *) "id", NULL
40081 };
40082
40083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40085 if (!SWIG_IsOK(res1)) {
40086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40087 }
40088 arg1 = reinterpret_cast< wxMenu * >(argp1);
40089 ecode2 = SWIG_AsVal_int(obj1, &val2);
40090 if (!SWIG_IsOK(ecode2)) {
40091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40092 }
40093 arg2 = static_cast< int >(val2);
40094 {
40095 PyThreadState* __tstate = wxPyBeginAllowThreads();
40096 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40097 wxPyEndAllowThreads(__tstate);
40098 if (PyErr_Occurred()) SWIG_fail;
40099 }
40100 {
40101 #if wxUSE_UNICODE
40102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40103 #else
40104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40105 #endif
40106 }
40107 return resultobj;
40108 fail:
40109 return NULL;
40110 }
40111
40112
40113 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40114 PyObject *resultobj = 0;
40115 wxMenu *arg1 = (wxMenu *) 0 ;
40116 wxString *arg2 = 0 ;
40117 void *argp1 = 0 ;
40118 int res1 = 0 ;
40119 bool temp2 = false ;
40120 PyObject * obj0 = 0 ;
40121 PyObject * obj1 = 0 ;
40122 char * kwnames[] = {
40123 (char *) "self",(char *) "title", NULL
40124 };
40125
40126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40128 if (!SWIG_IsOK(res1)) {
40129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40130 }
40131 arg1 = reinterpret_cast< wxMenu * >(argp1);
40132 {
40133 arg2 = wxString_in_helper(obj1);
40134 if (arg2 == NULL) SWIG_fail;
40135 temp2 = true;
40136 }
40137 {
40138 PyThreadState* __tstate = wxPyBeginAllowThreads();
40139 (arg1)->SetTitle((wxString const &)*arg2);
40140 wxPyEndAllowThreads(__tstate);
40141 if (PyErr_Occurred()) SWIG_fail;
40142 }
40143 resultobj = SWIG_Py_Void();
40144 {
40145 if (temp2)
40146 delete arg2;
40147 }
40148 return resultobj;
40149 fail:
40150 {
40151 if (temp2)
40152 delete arg2;
40153 }
40154 return NULL;
40155 }
40156
40157
40158 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40159 PyObject *resultobj = 0;
40160 wxMenu *arg1 = (wxMenu *) 0 ;
40161 wxString result;
40162 void *argp1 = 0 ;
40163 int res1 = 0 ;
40164 PyObject *swig_obj[1] ;
40165
40166 if (!args) SWIG_fail;
40167 swig_obj[0] = args;
40168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40169 if (!SWIG_IsOK(res1)) {
40170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40171 }
40172 arg1 = reinterpret_cast< wxMenu * >(argp1);
40173 {
40174 PyThreadState* __tstate = wxPyBeginAllowThreads();
40175 result = ((wxMenu const *)arg1)->GetTitle();
40176 wxPyEndAllowThreads(__tstate);
40177 if (PyErr_Occurred()) SWIG_fail;
40178 }
40179 {
40180 #if wxUSE_UNICODE
40181 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40182 #else
40183 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40184 #endif
40185 }
40186 return resultobj;
40187 fail:
40188 return NULL;
40189 }
40190
40191
40192 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40193 PyObject *resultobj = 0;
40194 wxMenu *arg1 = (wxMenu *) 0 ;
40195 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40196 void *argp1 = 0 ;
40197 int res1 = 0 ;
40198 void *argp2 = 0 ;
40199 int res2 = 0 ;
40200 PyObject * obj0 = 0 ;
40201 PyObject * obj1 = 0 ;
40202 char * kwnames[] = {
40203 (char *) "self",(char *) "handler", NULL
40204 };
40205
40206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40208 if (!SWIG_IsOK(res1)) {
40209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40210 }
40211 arg1 = reinterpret_cast< wxMenu * >(argp1);
40212 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40213 if (!SWIG_IsOK(res2)) {
40214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40215 }
40216 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40217 {
40218 PyThreadState* __tstate = wxPyBeginAllowThreads();
40219 (arg1)->SetEventHandler(arg2);
40220 wxPyEndAllowThreads(__tstate);
40221 if (PyErr_Occurred()) SWIG_fail;
40222 }
40223 resultobj = SWIG_Py_Void();
40224 return resultobj;
40225 fail:
40226 return NULL;
40227 }
40228
40229
40230 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40231 PyObject *resultobj = 0;
40232 wxMenu *arg1 = (wxMenu *) 0 ;
40233 wxEvtHandler *result = 0 ;
40234 void *argp1 = 0 ;
40235 int res1 = 0 ;
40236 PyObject *swig_obj[1] ;
40237
40238 if (!args) SWIG_fail;
40239 swig_obj[0] = args;
40240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40241 if (!SWIG_IsOK(res1)) {
40242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40243 }
40244 arg1 = reinterpret_cast< wxMenu * >(argp1);
40245 {
40246 PyThreadState* __tstate = wxPyBeginAllowThreads();
40247 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40248 wxPyEndAllowThreads(__tstate);
40249 if (PyErr_Occurred()) SWIG_fail;
40250 }
40251 {
40252 resultobj = wxPyMake_wxObject(result, 0);
40253 }
40254 return resultobj;
40255 fail:
40256 return NULL;
40257 }
40258
40259
40260 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40261 PyObject *resultobj = 0;
40262 wxMenu *arg1 = (wxMenu *) 0 ;
40263 wxWindow *arg2 = (wxWindow *) 0 ;
40264 void *argp1 = 0 ;
40265 int res1 = 0 ;
40266 void *argp2 = 0 ;
40267 int res2 = 0 ;
40268 PyObject * obj0 = 0 ;
40269 PyObject * obj1 = 0 ;
40270 char * kwnames[] = {
40271 (char *) "self",(char *) "win", NULL
40272 };
40273
40274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40276 if (!SWIG_IsOK(res1)) {
40277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40278 }
40279 arg1 = reinterpret_cast< wxMenu * >(argp1);
40280 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40281 if (!SWIG_IsOK(res2)) {
40282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40283 }
40284 arg2 = reinterpret_cast< wxWindow * >(argp2);
40285 {
40286 PyThreadState* __tstate = wxPyBeginAllowThreads();
40287 (arg1)->SetInvokingWindow(arg2);
40288 wxPyEndAllowThreads(__tstate);
40289 if (PyErr_Occurred()) SWIG_fail;
40290 }
40291 resultobj = SWIG_Py_Void();
40292 return resultobj;
40293 fail:
40294 return NULL;
40295 }
40296
40297
40298 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40299 PyObject *resultobj = 0;
40300 wxMenu *arg1 = (wxMenu *) 0 ;
40301 wxWindow *result = 0 ;
40302 void *argp1 = 0 ;
40303 int res1 = 0 ;
40304 PyObject *swig_obj[1] ;
40305
40306 if (!args) SWIG_fail;
40307 swig_obj[0] = args;
40308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40309 if (!SWIG_IsOK(res1)) {
40310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40311 }
40312 arg1 = reinterpret_cast< wxMenu * >(argp1);
40313 {
40314 PyThreadState* __tstate = wxPyBeginAllowThreads();
40315 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40316 wxPyEndAllowThreads(__tstate);
40317 if (PyErr_Occurred()) SWIG_fail;
40318 }
40319 {
40320 resultobj = wxPyMake_wxObject(result, 0);
40321 }
40322 return resultobj;
40323 fail:
40324 return NULL;
40325 }
40326
40327
40328 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40329 PyObject *resultobj = 0;
40330 wxMenu *arg1 = (wxMenu *) 0 ;
40331 long result;
40332 void *argp1 = 0 ;
40333 int res1 = 0 ;
40334 PyObject *swig_obj[1] ;
40335
40336 if (!args) SWIG_fail;
40337 swig_obj[0] = args;
40338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40339 if (!SWIG_IsOK(res1)) {
40340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40341 }
40342 arg1 = reinterpret_cast< wxMenu * >(argp1);
40343 {
40344 PyThreadState* __tstate = wxPyBeginAllowThreads();
40345 result = (long)((wxMenu const *)arg1)->GetStyle();
40346 wxPyEndAllowThreads(__tstate);
40347 if (PyErr_Occurred()) SWIG_fail;
40348 }
40349 resultobj = SWIG_From_long(static_cast< long >(result));
40350 return resultobj;
40351 fail:
40352 return NULL;
40353 }
40354
40355
40356 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40357 PyObject *resultobj = 0;
40358 wxMenu *arg1 = (wxMenu *) 0 ;
40359 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40360 void *argp1 = 0 ;
40361 int res1 = 0 ;
40362 void *argp2 = 0 ;
40363 int res2 = 0 ;
40364 PyObject * obj0 = 0 ;
40365 PyObject * obj1 = 0 ;
40366 char * kwnames[] = {
40367 (char *) "self",(char *) "source", NULL
40368 };
40369
40370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40372 if (!SWIG_IsOK(res1)) {
40373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40374 }
40375 arg1 = reinterpret_cast< wxMenu * >(argp1);
40376 if (obj1) {
40377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40378 if (!SWIG_IsOK(res2)) {
40379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40380 }
40381 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40382 }
40383 {
40384 PyThreadState* __tstate = wxPyBeginAllowThreads();
40385 (arg1)->UpdateUI(arg2);
40386 wxPyEndAllowThreads(__tstate);
40387 if (PyErr_Occurred()) SWIG_fail;
40388 }
40389 resultobj = SWIG_Py_Void();
40390 return resultobj;
40391 fail:
40392 return NULL;
40393 }
40394
40395
40396 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40397 PyObject *resultobj = 0;
40398 wxMenu *arg1 = (wxMenu *) 0 ;
40399 wxMenuBar *result = 0 ;
40400 void *argp1 = 0 ;
40401 int res1 = 0 ;
40402 PyObject *swig_obj[1] ;
40403
40404 if (!args) SWIG_fail;
40405 swig_obj[0] = args;
40406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40407 if (!SWIG_IsOK(res1)) {
40408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40409 }
40410 arg1 = reinterpret_cast< wxMenu * >(argp1);
40411 {
40412 PyThreadState* __tstate = wxPyBeginAllowThreads();
40413 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40414 wxPyEndAllowThreads(__tstate);
40415 if (PyErr_Occurred()) SWIG_fail;
40416 }
40417 {
40418 resultobj = wxPyMake_wxObject(result, (bool)0);
40419 }
40420 return resultobj;
40421 fail:
40422 return NULL;
40423 }
40424
40425
40426 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40427 PyObject *resultobj = 0;
40428 wxMenu *arg1 = (wxMenu *) 0 ;
40429 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40430 void *argp1 = 0 ;
40431 int res1 = 0 ;
40432 void *argp2 = 0 ;
40433 int res2 = 0 ;
40434 PyObject * obj0 = 0 ;
40435 PyObject * obj1 = 0 ;
40436 char * kwnames[] = {
40437 (char *) "self",(char *) "menubar", NULL
40438 };
40439
40440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40442 if (!SWIG_IsOK(res1)) {
40443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40444 }
40445 arg1 = reinterpret_cast< wxMenu * >(argp1);
40446 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40447 if (!SWIG_IsOK(res2)) {
40448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40449 }
40450 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40451 {
40452 PyThreadState* __tstate = wxPyBeginAllowThreads();
40453 (arg1)->Attach(arg2);
40454 wxPyEndAllowThreads(__tstate);
40455 if (PyErr_Occurred()) SWIG_fail;
40456 }
40457 resultobj = SWIG_Py_Void();
40458 return resultobj;
40459 fail:
40460 return NULL;
40461 }
40462
40463
40464 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40465 PyObject *resultobj = 0;
40466 wxMenu *arg1 = (wxMenu *) 0 ;
40467 void *argp1 = 0 ;
40468 int res1 = 0 ;
40469 PyObject *swig_obj[1] ;
40470
40471 if (!args) SWIG_fail;
40472 swig_obj[0] = args;
40473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40474 if (!SWIG_IsOK(res1)) {
40475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40476 }
40477 arg1 = reinterpret_cast< wxMenu * >(argp1);
40478 {
40479 PyThreadState* __tstate = wxPyBeginAllowThreads();
40480 (arg1)->Detach();
40481 wxPyEndAllowThreads(__tstate);
40482 if (PyErr_Occurred()) SWIG_fail;
40483 }
40484 resultobj = SWIG_Py_Void();
40485 return resultobj;
40486 fail:
40487 return NULL;
40488 }
40489
40490
40491 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40492 PyObject *resultobj = 0;
40493 wxMenu *arg1 = (wxMenu *) 0 ;
40494 bool result;
40495 void *argp1 = 0 ;
40496 int res1 = 0 ;
40497 PyObject *swig_obj[1] ;
40498
40499 if (!args) SWIG_fail;
40500 swig_obj[0] = args;
40501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40502 if (!SWIG_IsOK(res1)) {
40503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40504 }
40505 arg1 = reinterpret_cast< wxMenu * >(argp1);
40506 {
40507 PyThreadState* __tstate = wxPyBeginAllowThreads();
40508 result = (bool)((wxMenu const *)arg1)->IsAttached();
40509 wxPyEndAllowThreads(__tstate);
40510 if (PyErr_Occurred()) SWIG_fail;
40511 }
40512 {
40513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40514 }
40515 return resultobj;
40516 fail:
40517 return NULL;
40518 }
40519
40520
40521 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40522 PyObject *resultobj = 0;
40523 wxMenu *arg1 = (wxMenu *) 0 ;
40524 wxMenu *arg2 = (wxMenu *) 0 ;
40525 void *argp1 = 0 ;
40526 int res1 = 0 ;
40527 void *argp2 = 0 ;
40528 int res2 = 0 ;
40529 PyObject * obj0 = 0 ;
40530 PyObject * obj1 = 0 ;
40531 char * kwnames[] = {
40532 (char *) "self",(char *) "parent", NULL
40533 };
40534
40535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40537 if (!SWIG_IsOK(res1)) {
40538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40539 }
40540 arg1 = reinterpret_cast< wxMenu * >(argp1);
40541 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40542 if (!SWIG_IsOK(res2)) {
40543 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40544 }
40545 arg2 = reinterpret_cast< wxMenu * >(argp2);
40546 {
40547 PyThreadState* __tstate = wxPyBeginAllowThreads();
40548 (arg1)->SetParent(arg2);
40549 wxPyEndAllowThreads(__tstate);
40550 if (PyErr_Occurred()) SWIG_fail;
40551 }
40552 resultobj = SWIG_Py_Void();
40553 return resultobj;
40554 fail:
40555 return NULL;
40556 }
40557
40558
40559 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40560 PyObject *resultobj = 0;
40561 wxMenu *arg1 = (wxMenu *) 0 ;
40562 wxMenu *result = 0 ;
40563 void *argp1 = 0 ;
40564 int res1 = 0 ;
40565 PyObject *swig_obj[1] ;
40566
40567 if (!args) SWIG_fail;
40568 swig_obj[0] = args;
40569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40570 if (!SWIG_IsOK(res1)) {
40571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40572 }
40573 arg1 = reinterpret_cast< wxMenu * >(argp1);
40574 {
40575 PyThreadState* __tstate = wxPyBeginAllowThreads();
40576 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40577 wxPyEndAllowThreads(__tstate);
40578 if (PyErr_Occurred()) SWIG_fail;
40579 }
40580 {
40581 resultobj = wxPyMake_wxObject(result, 0);
40582 }
40583 return resultobj;
40584 fail:
40585 return NULL;
40586 }
40587
40588
40589 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40590 PyObject *obj;
40591 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40592 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40593 return SWIG_Py_Void();
40594 }
40595
40596 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40597 return SWIG_Python_InitShadowInstance(args);
40598 }
40599
40600 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40601 PyObject *resultobj = 0;
40602 long arg1 = (long) 0 ;
40603 wxMenuBar *result = 0 ;
40604 long val1 ;
40605 int ecode1 = 0 ;
40606 PyObject * obj0 = 0 ;
40607 char * kwnames[] = {
40608 (char *) "style", NULL
40609 };
40610
40611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40612 if (obj0) {
40613 ecode1 = SWIG_AsVal_long(obj0, &val1);
40614 if (!SWIG_IsOK(ecode1)) {
40615 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40616 }
40617 arg1 = static_cast< long >(val1);
40618 }
40619 {
40620 if (!wxPyCheckForApp()) SWIG_fail;
40621 PyThreadState* __tstate = wxPyBeginAllowThreads();
40622 result = (wxMenuBar *)new wxMenuBar(arg1);
40623 wxPyEndAllowThreads(__tstate);
40624 if (PyErr_Occurred()) SWIG_fail;
40625 }
40626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40627 return resultobj;
40628 fail:
40629 return NULL;
40630 }
40631
40632
40633 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40634 PyObject *resultobj = 0;
40635 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40636 wxMenu *arg2 = (wxMenu *) 0 ;
40637 wxString *arg3 = 0 ;
40638 bool result;
40639 void *argp1 = 0 ;
40640 int res1 = 0 ;
40641 void *argp2 = 0 ;
40642 int res2 = 0 ;
40643 bool temp3 = false ;
40644 PyObject * obj0 = 0 ;
40645 PyObject * obj1 = 0 ;
40646 PyObject * obj2 = 0 ;
40647 char * kwnames[] = {
40648 (char *) "self",(char *) "menu",(char *) "title", NULL
40649 };
40650
40651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40653 if (!SWIG_IsOK(res1)) {
40654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40655 }
40656 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40658 if (!SWIG_IsOK(res2)) {
40659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40660 }
40661 arg2 = reinterpret_cast< wxMenu * >(argp2);
40662 {
40663 arg3 = wxString_in_helper(obj2);
40664 if (arg3 == NULL) SWIG_fail;
40665 temp3 = true;
40666 }
40667 {
40668 PyThreadState* __tstate = wxPyBeginAllowThreads();
40669 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40670 wxPyEndAllowThreads(__tstate);
40671 if (PyErr_Occurred()) SWIG_fail;
40672 }
40673 {
40674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40675 }
40676 {
40677 if (temp3)
40678 delete arg3;
40679 }
40680 return resultobj;
40681 fail:
40682 {
40683 if (temp3)
40684 delete arg3;
40685 }
40686 return NULL;
40687 }
40688
40689
40690 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40691 PyObject *resultobj = 0;
40692 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40693 size_t arg2 ;
40694 wxMenu *arg3 = (wxMenu *) 0 ;
40695 wxString *arg4 = 0 ;
40696 bool result;
40697 void *argp1 = 0 ;
40698 int res1 = 0 ;
40699 size_t val2 ;
40700 int ecode2 = 0 ;
40701 void *argp3 = 0 ;
40702 int res3 = 0 ;
40703 bool temp4 = false ;
40704 PyObject * obj0 = 0 ;
40705 PyObject * obj1 = 0 ;
40706 PyObject * obj2 = 0 ;
40707 PyObject * obj3 = 0 ;
40708 char * kwnames[] = {
40709 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40710 };
40711
40712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40714 if (!SWIG_IsOK(res1)) {
40715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40716 }
40717 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40718 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40719 if (!SWIG_IsOK(ecode2)) {
40720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40721 }
40722 arg2 = static_cast< size_t >(val2);
40723 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40724 if (!SWIG_IsOK(res3)) {
40725 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40726 }
40727 arg3 = reinterpret_cast< wxMenu * >(argp3);
40728 {
40729 arg4 = wxString_in_helper(obj3);
40730 if (arg4 == NULL) SWIG_fail;
40731 temp4 = true;
40732 }
40733 {
40734 PyThreadState* __tstate = wxPyBeginAllowThreads();
40735 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40736 wxPyEndAllowThreads(__tstate);
40737 if (PyErr_Occurred()) SWIG_fail;
40738 }
40739 {
40740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40741 }
40742 {
40743 if (temp4)
40744 delete arg4;
40745 }
40746 return resultobj;
40747 fail:
40748 {
40749 if (temp4)
40750 delete arg4;
40751 }
40752 return NULL;
40753 }
40754
40755
40756 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40757 PyObject *resultobj = 0;
40758 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40759 size_t result;
40760 void *argp1 = 0 ;
40761 int res1 = 0 ;
40762 PyObject *swig_obj[1] ;
40763
40764 if (!args) SWIG_fail;
40765 swig_obj[0] = args;
40766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40767 if (!SWIG_IsOK(res1)) {
40768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40769 }
40770 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40771 {
40772 PyThreadState* __tstate = wxPyBeginAllowThreads();
40773 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40774 wxPyEndAllowThreads(__tstate);
40775 if (PyErr_Occurred()) SWIG_fail;
40776 }
40777 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40778 return resultobj;
40779 fail:
40780 return NULL;
40781 }
40782
40783
40784 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40785 PyObject *resultobj = 0;
40786 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40787 size_t arg2 ;
40788 wxMenu *result = 0 ;
40789 void *argp1 = 0 ;
40790 int res1 = 0 ;
40791 size_t val2 ;
40792 int ecode2 = 0 ;
40793 PyObject * obj0 = 0 ;
40794 PyObject * obj1 = 0 ;
40795 char * kwnames[] = {
40796 (char *) "self",(char *) "pos", NULL
40797 };
40798
40799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40801 if (!SWIG_IsOK(res1)) {
40802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40803 }
40804 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40805 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40806 if (!SWIG_IsOK(ecode2)) {
40807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40808 }
40809 arg2 = static_cast< size_t >(val2);
40810 {
40811 PyThreadState* __tstate = wxPyBeginAllowThreads();
40812 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40813 wxPyEndAllowThreads(__tstate);
40814 if (PyErr_Occurred()) SWIG_fail;
40815 }
40816 {
40817 resultobj = wxPyMake_wxObject(result, 0);
40818 }
40819 return resultobj;
40820 fail:
40821 return NULL;
40822 }
40823
40824
40825 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40826 PyObject *resultobj = 0;
40827 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40828 size_t arg2 ;
40829 wxMenu *arg3 = (wxMenu *) 0 ;
40830 wxString *arg4 = 0 ;
40831 wxMenu *result = 0 ;
40832 void *argp1 = 0 ;
40833 int res1 = 0 ;
40834 size_t val2 ;
40835 int ecode2 = 0 ;
40836 void *argp3 = 0 ;
40837 int res3 = 0 ;
40838 bool temp4 = false ;
40839 PyObject * obj0 = 0 ;
40840 PyObject * obj1 = 0 ;
40841 PyObject * obj2 = 0 ;
40842 PyObject * obj3 = 0 ;
40843 char * kwnames[] = {
40844 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40845 };
40846
40847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40849 if (!SWIG_IsOK(res1)) {
40850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40851 }
40852 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40853 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40854 if (!SWIG_IsOK(ecode2)) {
40855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40856 }
40857 arg2 = static_cast< size_t >(val2);
40858 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40859 if (!SWIG_IsOK(res3)) {
40860 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40861 }
40862 arg3 = reinterpret_cast< wxMenu * >(argp3);
40863 {
40864 arg4 = wxString_in_helper(obj3);
40865 if (arg4 == NULL) SWIG_fail;
40866 temp4 = true;
40867 }
40868 {
40869 PyThreadState* __tstate = wxPyBeginAllowThreads();
40870 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40871 wxPyEndAllowThreads(__tstate);
40872 if (PyErr_Occurred()) SWIG_fail;
40873 }
40874 {
40875 resultobj = wxPyMake_wxObject(result, 0);
40876 }
40877 {
40878 if (temp4)
40879 delete arg4;
40880 }
40881 return resultobj;
40882 fail:
40883 {
40884 if (temp4)
40885 delete arg4;
40886 }
40887 return NULL;
40888 }
40889
40890
40891 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40892 PyObject *resultobj = 0;
40893 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40894 size_t arg2 ;
40895 wxMenu *result = 0 ;
40896 void *argp1 = 0 ;
40897 int res1 = 0 ;
40898 size_t val2 ;
40899 int ecode2 = 0 ;
40900 PyObject * obj0 = 0 ;
40901 PyObject * obj1 = 0 ;
40902 char * kwnames[] = {
40903 (char *) "self",(char *) "pos", NULL
40904 };
40905
40906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40908 if (!SWIG_IsOK(res1)) {
40909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40910 }
40911 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40912 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40913 if (!SWIG_IsOK(ecode2)) {
40914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
40915 }
40916 arg2 = static_cast< size_t >(val2);
40917 {
40918 PyThreadState* __tstate = wxPyBeginAllowThreads();
40919 result = (wxMenu *)(arg1)->Remove(arg2);
40920 wxPyEndAllowThreads(__tstate);
40921 if (PyErr_Occurred()) SWIG_fail;
40922 }
40923 {
40924 resultobj = wxPyMake_wxObject(result, 0);
40925 }
40926 return resultobj;
40927 fail:
40928 return NULL;
40929 }
40930
40931
40932 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40933 PyObject *resultobj = 0;
40934 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40935 size_t arg2 ;
40936 bool arg3 ;
40937 void *argp1 = 0 ;
40938 int res1 = 0 ;
40939 size_t val2 ;
40940 int ecode2 = 0 ;
40941 bool val3 ;
40942 int ecode3 = 0 ;
40943 PyObject * obj0 = 0 ;
40944 PyObject * obj1 = 0 ;
40945 PyObject * obj2 = 0 ;
40946 char * kwnames[] = {
40947 (char *) "self",(char *) "pos",(char *) "enable", NULL
40948 };
40949
40950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40952 if (!SWIG_IsOK(res1)) {
40953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40954 }
40955 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40956 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40957 if (!SWIG_IsOK(ecode2)) {
40958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
40959 }
40960 arg2 = static_cast< size_t >(val2);
40961 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40962 if (!SWIG_IsOK(ecode3)) {
40963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
40964 }
40965 arg3 = static_cast< bool >(val3);
40966 {
40967 PyThreadState* __tstate = wxPyBeginAllowThreads();
40968 (arg1)->EnableTop(arg2,arg3);
40969 wxPyEndAllowThreads(__tstate);
40970 if (PyErr_Occurred()) SWIG_fail;
40971 }
40972 resultobj = SWIG_Py_Void();
40973 return resultobj;
40974 fail:
40975 return NULL;
40976 }
40977
40978
40979 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40980 PyObject *resultobj = 0;
40981 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40982 size_t arg2 ;
40983 bool result;
40984 void *argp1 = 0 ;
40985 int res1 = 0 ;
40986 size_t val2 ;
40987 int ecode2 = 0 ;
40988 PyObject * obj0 = 0 ;
40989 PyObject * obj1 = 0 ;
40990 char * kwnames[] = {
40991 (char *) "self",(char *) "pos", NULL
40992 };
40993
40994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
40995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40996 if (!SWIG_IsOK(res1)) {
40997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40998 }
40999 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41000 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41001 if (!SWIG_IsOK(ecode2)) {
41002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41003 }
41004 arg2 = static_cast< size_t >(val2);
41005 {
41006 PyThreadState* __tstate = wxPyBeginAllowThreads();
41007 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41008 wxPyEndAllowThreads(__tstate);
41009 if (PyErr_Occurred()) SWIG_fail;
41010 }
41011 {
41012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41013 }
41014 return resultobj;
41015 fail:
41016 return NULL;
41017 }
41018
41019
41020 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41021 PyObject *resultobj = 0;
41022 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41023 size_t arg2 ;
41024 wxString *arg3 = 0 ;
41025 void *argp1 = 0 ;
41026 int res1 = 0 ;
41027 size_t val2 ;
41028 int ecode2 = 0 ;
41029 bool temp3 = false ;
41030 PyObject * obj0 = 0 ;
41031 PyObject * obj1 = 0 ;
41032 PyObject * obj2 = 0 ;
41033 char * kwnames[] = {
41034 (char *) "self",(char *) "pos",(char *) "label", NULL
41035 };
41036
41037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41039 if (!SWIG_IsOK(res1)) {
41040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41041 }
41042 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41043 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41044 if (!SWIG_IsOK(ecode2)) {
41045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41046 }
41047 arg2 = static_cast< size_t >(val2);
41048 {
41049 arg3 = wxString_in_helper(obj2);
41050 if (arg3 == NULL) SWIG_fail;
41051 temp3 = true;
41052 }
41053 {
41054 PyThreadState* __tstate = wxPyBeginAllowThreads();
41055 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41056 wxPyEndAllowThreads(__tstate);
41057 if (PyErr_Occurred()) SWIG_fail;
41058 }
41059 resultobj = SWIG_Py_Void();
41060 {
41061 if (temp3)
41062 delete arg3;
41063 }
41064 return resultobj;
41065 fail:
41066 {
41067 if (temp3)
41068 delete arg3;
41069 }
41070 return NULL;
41071 }
41072
41073
41074 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41075 PyObject *resultobj = 0;
41076 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41077 size_t arg2 ;
41078 wxString result;
41079 void *argp1 = 0 ;
41080 int res1 = 0 ;
41081 size_t val2 ;
41082 int ecode2 = 0 ;
41083 PyObject * obj0 = 0 ;
41084 PyObject * obj1 = 0 ;
41085 char * kwnames[] = {
41086 (char *) "self",(char *) "pos", NULL
41087 };
41088
41089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41091 if (!SWIG_IsOK(res1)) {
41092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41093 }
41094 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41095 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41096 if (!SWIG_IsOK(ecode2)) {
41097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41098 }
41099 arg2 = static_cast< size_t >(val2);
41100 {
41101 PyThreadState* __tstate = wxPyBeginAllowThreads();
41102 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41103 wxPyEndAllowThreads(__tstate);
41104 if (PyErr_Occurred()) SWIG_fail;
41105 }
41106 {
41107 #if wxUSE_UNICODE
41108 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41109 #else
41110 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41111 #endif
41112 }
41113 return resultobj;
41114 fail:
41115 return NULL;
41116 }
41117
41118
41119 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41120 PyObject *resultobj = 0;
41121 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41122 wxString *arg2 = 0 ;
41123 wxString *arg3 = 0 ;
41124 int result;
41125 void *argp1 = 0 ;
41126 int res1 = 0 ;
41127 bool temp2 = false ;
41128 bool temp3 = false ;
41129 PyObject * obj0 = 0 ;
41130 PyObject * obj1 = 0 ;
41131 PyObject * obj2 = 0 ;
41132 char * kwnames[] = {
41133 (char *) "self",(char *) "menu",(char *) "item", NULL
41134 };
41135
41136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41138 if (!SWIG_IsOK(res1)) {
41139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41140 }
41141 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41142 {
41143 arg2 = wxString_in_helper(obj1);
41144 if (arg2 == NULL) SWIG_fail;
41145 temp2 = true;
41146 }
41147 {
41148 arg3 = wxString_in_helper(obj2);
41149 if (arg3 == NULL) SWIG_fail;
41150 temp3 = true;
41151 }
41152 {
41153 PyThreadState* __tstate = wxPyBeginAllowThreads();
41154 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41155 wxPyEndAllowThreads(__tstate);
41156 if (PyErr_Occurred()) SWIG_fail;
41157 }
41158 resultobj = SWIG_From_int(static_cast< int >(result));
41159 {
41160 if (temp2)
41161 delete arg2;
41162 }
41163 {
41164 if (temp3)
41165 delete arg3;
41166 }
41167 return resultobj;
41168 fail:
41169 {
41170 if (temp2)
41171 delete arg2;
41172 }
41173 {
41174 if (temp3)
41175 delete arg3;
41176 }
41177 return NULL;
41178 }
41179
41180
41181 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41182 PyObject *resultobj = 0;
41183 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41184 int arg2 ;
41185 wxMenuItem *result = 0 ;
41186 void *argp1 = 0 ;
41187 int res1 = 0 ;
41188 int val2 ;
41189 int ecode2 = 0 ;
41190 PyObject * obj0 = 0 ;
41191 PyObject * obj1 = 0 ;
41192 char * kwnames[] = {
41193 (char *) "self",(char *) "id", NULL
41194 };
41195
41196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41198 if (!SWIG_IsOK(res1)) {
41199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41200 }
41201 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41202 ecode2 = SWIG_AsVal_int(obj1, &val2);
41203 if (!SWIG_IsOK(ecode2)) {
41204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41205 }
41206 arg2 = static_cast< int >(val2);
41207 {
41208 PyThreadState* __tstate = wxPyBeginAllowThreads();
41209 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41210 wxPyEndAllowThreads(__tstate);
41211 if (PyErr_Occurred()) SWIG_fail;
41212 }
41213 {
41214 resultobj = wxPyMake_wxObject(result, (bool)0);
41215 }
41216 return resultobj;
41217 fail:
41218 return NULL;
41219 }
41220
41221
41222 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41223 PyObject *resultobj = 0;
41224 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41225 wxString *arg2 = 0 ;
41226 int result;
41227 void *argp1 = 0 ;
41228 int res1 = 0 ;
41229 bool temp2 = false ;
41230 PyObject * obj0 = 0 ;
41231 PyObject * obj1 = 0 ;
41232 char * kwnames[] = {
41233 (char *) "self",(char *) "title", NULL
41234 };
41235
41236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41238 if (!SWIG_IsOK(res1)) {
41239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41240 }
41241 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41242 {
41243 arg2 = wxString_in_helper(obj1);
41244 if (arg2 == NULL) SWIG_fail;
41245 temp2 = true;
41246 }
41247 {
41248 PyThreadState* __tstate = wxPyBeginAllowThreads();
41249 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41250 wxPyEndAllowThreads(__tstate);
41251 if (PyErr_Occurred()) SWIG_fail;
41252 }
41253 resultobj = SWIG_From_int(static_cast< int >(result));
41254 {
41255 if (temp2)
41256 delete arg2;
41257 }
41258 return resultobj;
41259 fail:
41260 {
41261 if (temp2)
41262 delete arg2;
41263 }
41264 return NULL;
41265 }
41266
41267
41268 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41269 PyObject *resultobj = 0;
41270 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41271 int arg2 ;
41272 bool arg3 ;
41273 void *argp1 = 0 ;
41274 int res1 = 0 ;
41275 int val2 ;
41276 int ecode2 = 0 ;
41277 bool val3 ;
41278 int ecode3 = 0 ;
41279 PyObject * obj0 = 0 ;
41280 PyObject * obj1 = 0 ;
41281 PyObject * obj2 = 0 ;
41282 char * kwnames[] = {
41283 (char *) "self",(char *) "id",(char *) "enable", NULL
41284 };
41285
41286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41288 if (!SWIG_IsOK(res1)) {
41289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41290 }
41291 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41292 ecode2 = SWIG_AsVal_int(obj1, &val2);
41293 if (!SWIG_IsOK(ecode2)) {
41294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41295 }
41296 arg2 = static_cast< int >(val2);
41297 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41298 if (!SWIG_IsOK(ecode3)) {
41299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41300 }
41301 arg3 = static_cast< bool >(val3);
41302 {
41303 PyThreadState* __tstate = wxPyBeginAllowThreads();
41304 (arg1)->Enable(arg2,arg3);
41305 wxPyEndAllowThreads(__tstate);
41306 if (PyErr_Occurred()) SWIG_fail;
41307 }
41308 resultobj = SWIG_Py_Void();
41309 return resultobj;
41310 fail:
41311 return NULL;
41312 }
41313
41314
41315 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41316 PyObject *resultobj = 0;
41317 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41318 int arg2 ;
41319 bool arg3 ;
41320 void *argp1 = 0 ;
41321 int res1 = 0 ;
41322 int val2 ;
41323 int ecode2 = 0 ;
41324 bool val3 ;
41325 int ecode3 = 0 ;
41326 PyObject * obj0 = 0 ;
41327 PyObject * obj1 = 0 ;
41328 PyObject * obj2 = 0 ;
41329 char * kwnames[] = {
41330 (char *) "self",(char *) "id",(char *) "check", NULL
41331 };
41332
41333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41335 if (!SWIG_IsOK(res1)) {
41336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41337 }
41338 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41339 ecode2 = SWIG_AsVal_int(obj1, &val2);
41340 if (!SWIG_IsOK(ecode2)) {
41341 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41342 }
41343 arg2 = static_cast< int >(val2);
41344 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41345 if (!SWIG_IsOK(ecode3)) {
41346 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41347 }
41348 arg3 = static_cast< bool >(val3);
41349 {
41350 PyThreadState* __tstate = wxPyBeginAllowThreads();
41351 (arg1)->Check(arg2,arg3);
41352 wxPyEndAllowThreads(__tstate);
41353 if (PyErr_Occurred()) SWIG_fail;
41354 }
41355 resultobj = SWIG_Py_Void();
41356 return resultobj;
41357 fail:
41358 return NULL;
41359 }
41360
41361
41362 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41363 PyObject *resultobj = 0;
41364 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41365 int arg2 ;
41366 bool result;
41367 void *argp1 = 0 ;
41368 int res1 = 0 ;
41369 int val2 ;
41370 int ecode2 = 0 ;
41371 PyObject * obj0 = 0 ;
41372 PyObject * obj1 = 0 ;
41373 char * kwnames[] = {
41374 (char *) "self",(char *) "id", NULL
41375 };
41376
41377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41379 if (!SWIG_IsOK(res1)) {
41380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41381 }
41382 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41383 ecode2 = SWIG_AsVal_int(obj1, &val2);
41384 if (!SWIG_IsOK(ecode2)) {
41385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41386 }
41387 arg2 = static_cast< int >(val2);
41388 {
41389 PyThreadState* __tstate = wxPyBeginAllowThreads();
41390 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41391 wxPyEndAllowThreads(__tstate);
41392 if (PyErr_Occurred()) SWIG_fail;
41393 }
41394 {
41395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41396 }
41397 return resultobj;
41398 fail:
41399 return NULL;
41400 }
41401
41402
41403 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41404 PyObject *resultobj = 0;
41405 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41406 int arg2 ;
41407 bool result;
41408 void *argp1 = 0 ;
41409 int res1 = 0 ;
41410 int val2 ;
41411 int ecode2 = 0 ;
41412 PyObject * obj0 = 0 ;
41413 PyObject * obj1 = 0 ;
41414 char * kwnames[] = {
41415 (char *) "self",(char *) "id", NULL
41416 };
41417
41418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41420 if (!SWIG_IsOK(res1)) {
41421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41422 }
41423 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41424 ecode2 = SWIG_AsVal_int(obj1, &val2);
41425 if (!SWIG_IsOK(ecode2)) {
41426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41427 }
41428 arg2 = static_cast< int >(val2);
41429 {
41430 PyThreadState* __tstate = wxPyBeginAllowThreads();
41431 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41432 wxPyEndAllowThreads(__tstate);
41433 if (PyErr_Occurred()) SWIG_fail;
41434 }
41435 {
41436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41437 }
41438 return resultobj;
41439 fail:
41440 return NULL;
41441 }
41442
41443
41444 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41445 PyObject *resultobj = 0;
41446 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41447 int arg2 ;
41448 wxString *arg3 = 0 ;
41449 void *argp1 = 0 ;
41450 int res1 = 0 ;
41451 int val2 ;
41452 int ecode2 = 0 ;
41453 bool temp3 = false ;
41454 PyObject * obj0 = 0 ;
41455 PyObject * obj1 = 0 ;
41456 PyObject * obj2 = 0 ;
41457 char * kwnames[] = {
41458 (char *) "self",(char *) "id",(char *) "label", NULL
41459 };
41460
41461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41463 if (!SWIG_IsOK(res1)) {
41464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41465 }
41466 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41467 ecode2 = SWIG_AsVal_int(obj1, &val2);
41468 if (!SWIG_IsOK(ecode2)) {
41469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41470 }
41471 arg2 = static_cast< int >(val2);
41472 {
41473 arg3 = wxString_in_helper(obj2);
41474 if (arg3 == NULL) SWIG_fail;
41475 temp3 = true;
41476 }
41477 {
41478 PyThreadState* __tstate = wxPyBeginAllowThreads();
41479 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41480 wxPyEndAllowThreads(__tstate);
41481 if (PyErr_Occurred()) SWIG_fail;
41482 }
41483 resultobj = SWIG_Py_Void();
41484 {
41485 if (temp3)
41486 delete arg3;
41487 }
41488 return resultobj;
41489 fail:
41490 {
41491 if (temp3)
41492 delete arg3;
41493 }
41494 return NULL;
41495 }
41496
41497
41498 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41499 PyObject *resultobj = 0;
41500 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41501 int arg2 ;
41502 wxString result;
41503 void *argp1 = 0 ;
41504 int res1 = 0 ;
41505 int val2 ;
41506 int ecode2 = 0 ;
41507 PyObject * obj0 = 0 ;
41508 PyObject * obj1 = 0 ;
41509 char * kwnames[] = {
41510 (char *) "self",(char *) "id", NULL
41511 };
41512
41513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41515 if (!SWIG_IsOK(res1)) {
41516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41517 }
41518 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41519 ecode2 = SWIG_AsVal_int(obj1, &val2);
41520 if (!SWIG_IsOK(ecode2)) {
41521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41522 }
41523 arg2 = static_cast< int >(val2);
41524 {
41525 PyThreadState* __tstate = wxPyBeginAllowThreads();
41526 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41527 wxPyEndAllowThreads(__tstate);
41528 if (PyErr_Occurred()) SWIG_fail;
41529 }
41530 {
41531 #if wxUSE_UNICODE
41532 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41533 #else
41534 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41535 #endif
41536 }
41537 return resultobj;
41538 fail:
41539 return NULL;
41540 }
41541
41542
41543 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41544 PyObject *resultobj = 0;
41545 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41546 int arg2 ;
41547 wxString *arg3 = 0 ;
41548 void *argp1 = 0 ;
41549 int res1 = 0 ;
41550 int val2 ;
41551 int ecode2 = 0 ;
41552 bool temp3 = false ;
41553 PyObject * obj0 = 0 ;
41554 PyObject * obj1 = 0 ;
41555 PyObject * obj2 = 0 ;
41556 char * kwnames[] = {
41557 (char *) "self",(char *) "id",(char *) "helpString", NULL
41558 };
41559
41560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41562 if (!SWIG_IsOK(res1)) {
41563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41564 }
41565 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41566 ecode2 = SWIG_AsVal_int(obj1, &val2);
41567 if (!SWIG_IsOK(ecode2)) {
41568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41569 }
41570 arg2 = static_cast< int >(val2);
41571 {
41572 arg3 = wxString_in_helper(obj2);
41573 if (arg3 == NULL) SWIG_fail;
41574 temp3 = true;
41575 }
41576 {
41577 PyThreadState* __tstate = wxPyBeginAllowThreads();
41578 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41579 wxPyEndAllowThreads(__tstate);
41580 if (PyErr_Occurred()) SWIG_fail;
41581 }
41582 resultobj = SWIG_Py_Void();
41583 {
41584 if (temp3)
41585 delete arg3;
41586 }
41587 return resultobj;
41588 fail:
41589 {
41590 if (temp3)
41591 delete arg3;
41592 }
41593 return NULL;
41594 }
41595
41596
41597 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41598 PyObject *resultobj = 0;
41599 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41600 int arg2 ;
41601 wxString result;
41602 void *argp1 = 0 ;
41603 int res1 = 0 ;
41604 int val2 ;
41605 int ecode2 = 0 ;
41606 PyObject * obj0 = 0 ;
41607 PyObject * obj1 = 0 ;
41608 char * kwnames[] = {
41609 (char *) "self",(char *) "id", NULL
41610 };
41611
41612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41614 if (!SWIG_IsOK(res1)) {
41615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41616 }
41617 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41618 ecode2 = SWIG_AsVal_int(obj1, &val2);
41619 if (!SWIG_IsOK(ecode2)) {
41620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41621 }
41622 arg2 = static_cast< int >(val2);
41623 {
41624 PyThreadState* __tstate = wxPyBeginAllowThreads();
41625 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41626 wxPyEndAllowThreads(__tstate);
41627 if (PyErr_Occurred()) SWIG_fail;
41628 }
41629 {
41630 #if wxUSE_UNICODE
41631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41632 #else
41633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41634 #endif
41635 }
41636 return resultobj;
41637 fail:
41638 return NULL;
41639 }
41640
41641
41642 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41643 PyObject *resultobj = 0;
41644 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41645 wxFrame *result = 0 ;
41646 void *argp1 = 0 ;
41647 int res1 = 0 ;
41648 PyObject *swig_obj[1] ;
41649
41650 if (!args) SWIG_fail;
41651 swig_obj[0] = args;
41652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41653 if (!SWIG_IsOK(res1)) {
41654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41655 }
41656 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41657 {
41658 PyThreadState* __tstate = wxPyBeginAllowThreads();
41659 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41660 wxPyEndAllowThreads(__tstate);
41661 if (PyErr_Occurred()) SWIG_fail;
41662 }
41663 {
41664 resultobj = wxPyMake_wxObject(result, (bool)0);
41665 }
41666 return resultobj;
41667 fail:
41668 return NULL;
41669 }
41670
41671
41672 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41673 PyObject *resultobj = 0;
41674 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41675 bool result;
41676 void *argp1 = 0 ;
41677 int res1 = 0 ;
41678 PyObject *swig_obj[1] ;
41679
41680 if (!args) SWIG_fail;
41681 swig_obj[0] = args;
41682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41683 if (!SWIG_IsOK(res1)) {
41684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41685 }
41686 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41687 {
41688 PyThreadState* __tstate = wxPyBeginAllowThreads();
41689 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41690 wxPyEndAllowThreads(__tstate);
41691 if (PyErr_Occurred()) SWIG_fail;
41692 }
41693 {
41694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41695 }
41696 return resultobj;
41697 fail:
41698 return NULL;
41699 }
41700
41701
41702 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41703 PyObject *resultobj = 0;
41704 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41705 wxFrame *arg2 = (wxFrame *) 0 ;
41706 void *argp1 = 0 ;
41707 int res1 = 0 ;
41708 void *argp2 = 0 ;
41709 int res2 = 0 ;
41710 PyObject * obj0 = 0 ;
41711 PyObject * obj1 = 0 ;
41712 char * kwnames[] = {
41713 (char *) "self",(char *) "frame", NULL
41714 };
41715
41716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41718 if (!SWIG_IsOK(res1)) {
41719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41720 }
41721 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41722 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41723 if (!SWIG_IsOK(res2)) {
41724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41725 }
41726 arg2 = reinterpret_cast< wxFrame * >(argp2);
41727 {
41728 PyThreadState* __tstate = wxPyBeginAllowThreads();
41729 (arg1)->Attach(arg2);
41730 wxPyEndAllowThreads(__tstate);
41731 if (PyErr_Occurred()) SWIG_fail;
41732 }
41733 resultobj = SWIG_Py_Void();
41734 return resultobj;
41735 fail:
41736 return NULL;
41737 }
41738
41739
41740 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41741 PyObject *resultobj = 0;
41742 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41743 void *argp1 = 0 ;
41744 int res1 = 0 ;
41745 PyObject *swig_obj[1] ;
41746
41747 if (!args) SWIG_fail;
41748 swig_obj[0] = args;
41749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41750 if (!SWIG_IsOK(res1)) {
41751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41752 }
41753 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41754 {
41755 PyThreadState* __tstate = wxPyBeginAllowThreads();
41756 (arg1)->Detach();
41757 wxPyEndAllowThreads(__tstate);
41758 if (PyErr_Occurred()) SWIG_fail;
41759 }
41760 resultobj = SWIG_Py_Void();
41761 return resultobj;
41762 fail:
41763 return NULL;
41764 }
41765
41766
41767 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41768 PyObject *resultobj = 0;
41769 bool arg1 ;
41770 bool val1 ;
41771 int ecode1 = 0 ;
41772 PyObject * obj0 = 0 ;
41773 char * kwnames[] = {
41774 (char *) "enable", NULL
41775 };
41776
41777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41778 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41779 if (!SWIG_IsOK(ecode1)) {
41780 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41781 }
41782 arg1 = static_cast< bool >(val1);
41783 {
41784 PyThreadState* __tstate = wxPyBeginAllowThreads();
41785 wxMenuBar_SetAutoWindowMenu(arg1);
41786 wxPyEndAllowThreads(__tstate);
41787 if (PyErr_Occurred()) SWIG_fail;
41788 }
41789 resultobj = SWIG_Py_Void();
41790 return resultobj;
41791 fail:
41792 return NULL;
41793 }
41794
41795
41796 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41797 PyObject *resultobj = 0;
41798 bool result;
41799
41800 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41801 {
41802 PyThreadState* __tstate = wxPyBeginAllowThreads();
41803 result = (bool)wxMenuBar_GetAutoWindowMenu();
41804 wxPyEndAllowThreads(__tstate);
41805 if (PyErr_Occurred()) SWIG_fail;
41806 }
41807 {
41808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41809 }
41810 return resultobj;
41811 fail:
41812 return NULL;
41813 }
41814
41815
41816 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41817 PyObject *obj;
41818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41819 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41820 return SWIG_Py_Void();
41821 }
41822
41823 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41824 return SWIG_Python_InitShadowInstance(args);
41825 }
41826
41827 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41828 PyObject *resultobj = 0;
41829 wxMenu *arg1 = (wxMenu *) NULL ;
41830 int arg2 = (int) wxID_ANY ;
41831 wxString const &arg3_defvalue = wxPyEmptyString ;
41832 wxString *arg3 = (wxString *) &arg3_defvalue ;
41833 wxString const &arg4_defvalue = wxPyEmptyString ;
41834 wxString *arg4 = (wxString *) &arg4_defvalue ;
41835 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41836 wxMenu *arg6 = (wxMenu *) NULL ;
41837 wxMenuItem *result = 0 ;
41838 void *argp1 = 0 ;
41839 int res1 = 0 ;
41840 int val2 ;
41841 int ecode2 = 0 ;
41842 bool temp3 = false ;
41843 bool temp4 = false ;
41844 int val5 ;
41845 int ecode5 = 0 ;
41846 void *argp6 = 0 ;
41847 int res6 = 0 ;
41848 PyObject * obj0 = 0 ;
41849 PyObject * obj1 = 0 ;
41850 PyObject * obj2 = 0 ;
41851 PyObject * obj3 = 0 ;
41852 PyObject * obj4 = 0 ;
41853 PyObject * obj5 = 0 ;
41854 char * kwnames[] = {
41855 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41856 };
41857
41858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41859 if (obj0) {
41860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41861 if (!SWIG_IsOK(res1)) {
41862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41863 }
41864 arg1 = reinterpret_cast< wxMenu * >(argp1);
41865 }
41866 if (obj1) {
41867 ecode2 = SWIG_AsVal_int(obj1, &val2);
41868 if (!SWIG_IsOK(ecode2)) {
41869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41870 }
41871 arg2 = static_cast< int >(val2);
41872 }
41873 if (obj2) {
41874 {
41875 arg3 = wxString_in_helper(obj2);
41876 if (arg3 == NULL) SWIG_fail;
41877 temp3 = true;
41878 }
41879 }
41880 if (obj3) {
41881 {
41882 arg4 = wxString_in_helper(obj3);
41883 if (arg4 == NULL) SWIG_fail;
41884 temp4 = true;
41885 }
41886 }
41887 if (obj4) {
41888 ecode5 = SWIG_AsVal_int(obj4, &val5);
41889 if (!SWIG_IsOK(ecode5)) {
41890 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
41891 }
41892 arg5 = static_cast< wxItemKind >(val5);
41893 }
41894 if (obj5) {
41895 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
41896 if (!SWIG_IsOK(res6)) {
41897 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
41898 }
41899 arg6 = reinterpret_cast< wxMenu * >(argp6);
41900 }
41901 {
41902 PyThreadState* __tstate = wxPyBeginAllowThreads();
41903 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
41904 wxPyEndAllowThreads(__tstate);
41905 if (PyErr_Occurred()) SWIG_fail;
41906 }
41907 {
41908 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
41909 }
41910 {
41911 if (temp3)
41912 delete arg3;
41913 }
41914 {
41915 if (temp4)
41916 delete arg4;
41917 }
41918 return resultobj;
41919 fail:
41920 {
41921 if (temp3)
41922 delete arg3;
41923 }
41924 {
41925 if (temp4)
41926 delete arg4;
41927 }
41928 return NULL;
41929 }
41930
41931
41932 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41933 PyObject *resultobj = 0;
41934 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41935 void *argp1 = 0 ;
41936 int res1 = 0 ;
41937 PyObject *swig_obj[1] ;
41938
41939 if (!args) SWIG_fail;
41940 swig_obj[0] = args;
41941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
41942 if (!SWIG_IsOK(res1)) {
41943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41944 }
41945 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41946 {
41947 PyThreadState* __tstate = wxPyBeginAllowThreads();
41948 delete arg1;
41949
41950 wxPyEndAllowThreads(__tstate);
41951 if (PyErr_Occurred()) SWIG_fail;
41952 }
41953 resultobj = SWIG_Py_Void();
41954 return resultobj;
41955 fail:
41956 return NULL;
41957 }
41958
41959
41960 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41961 PyObject *resultobj = 0;
41962 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41963 wxMenu *result = 0 ;
41964 void *argp1 = 0 ;
41965 int res1 = 0 ;
41966 PyObject *swig_obj[1] ;
41967
41968 if (!args) SWIG_fail;
41969 swig_obj[0] = args;
41970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41971 if (!SWIG_IsOK(res1)) {
41972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41973 }
41974 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41975 {
41976 PyThreadState* __tstate = wxPyBeginAllowThreads();
41977 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
41978 wxPyEndAllowThreads(__tstate);
41979 if (PyErr_Occurred()) SWIG_fail;
41980 }
41981 {
41982 resultobj = wxPyMake_wxObject(result, 0);
41983 }
41984 return resultobj;
41985 fail:
41986 return NULL;
41987 }
41988
41989
41990 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41991 PyObject *resultobj = 0;
41992 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41993 wxMenu *arg2 = (wxMenu *) 0 ;
41994 void *argp1 = 0 ;
41995 int res1 = 0 ;
41996 void *argp2 = 0 ;
41997 int res2 = 0 ;
41998 PyObject * obj0 = 0 ;
41999 PyObject * obj1 = 0 ;
42000 char * kwnames[] = {
42001 (char *) "self",(char *) "menu", NULL
42002 };
42003
42004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42006 if (!SWIG_IsOK(res1)) {
42007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42008 }
42009 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42010 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42011 if (!SWIG_IsOK(res2)) {
42012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42013 }
42014 arg2 = reinterpret_cast< wxMenu * >(argp2);
42015 {
42016 PyThreadState* __tstate = wxPyBeginAllowThreads();
42017 (arg1)->SetMenu(arg2);
42018 wxPyEndAllowThreads(__tstate);
42019 if (PyErr_Occurred()) SWIG_fail;
42020 }
42021 resultobj = SWIG_Py_Void();
42022 return resultobj;
42023 fail:
42024 return NULL;
42025 }
42026
42027
42028 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42029 PyObject *resultobj = 0;
42030 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42031 int arg2 ;
42032 void *argp1 = 0 ;
42033 int res1 = 0 ;
42034 int val2 ;
42035 int ecode2 = 0 ;
42036 PyObject * obj0 = 0 ;
42037 PyObject * obj1 = 0 ;
42038 char * kwnames[] = {
42039 (char *) "self",(char *) "id", NULL
42040 };
42041
42042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42044 if (!SWIG_IsOK(res1)) {
42045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42046 }
42047 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42048 ecode2 = SWIG_AsVal_int(obj1, &val2);
42049 if (!SWIG_IsOK(ecode2)) {
42050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42051 }
42052 arg2 = static_cast< int >(val2);
42053 {
42054 PyThreadState* __tstate = wxPyBeginAllowThreads();
42055 (arg1)->SetId(arg2);
42056 wxPyEndAllowThreads(__tstate);
42057 if (PyErr_Occurred()) SWIG_fail;
42058 }
42059 resultobj = SWIG_Py_Void();
42060 return resultobj;
42061 fail:
42062 return NULL;
42063 }
42064
42065
42066 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42067 PyObject *resultobj = 0;
42068 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42069 int result;
42070 void *argp1 = 0 ;
42071 int res1 = 0 ;
42072 PyObject *swig_obj[1] ;
42073
42074 if (!args) SWIG_fail;
42075 swig_obj[0] = args;
42076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42077 if (!SWIG_IsOK(res1)) {
42078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42079 }
42080 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42081 {
42082 PyThreadState* __tstate = wxPyBeginAllowThreads();
42083 result = (int)((wxMenuItem const *)arg1)->GetId();
42084 wxPyEndAllowThreads(__tstate);
42085 if (PyErr_Occurred()) SWIG_fail;
42086 }
42087 resultobj = SWIG_From_int(static_cast< int >(result));
42088 return resultobj;
42089 fail:
42090 return NULL;
42091 }
42092
42093
42094 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42095 PyObject *resultobj = 0;
42096 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42097 bool result;
42098 void *argp1 = 0 ;
42099 int res1 = 0 ;
42100 PyObject *swig_obj[1] ;
42101
42102 if (!args) SWIG_fail;
42103 swig_obj[0] = args;
42104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42105 if (!SWIG_IsOK(res1)) {
42106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42107 }
42108 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42109 {
42110 PyThreadState* __tstate = wxPyBeginAllowThreads();
42111 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42112 wxPyEndAllowThreads(__tstate);
42113 if (PyErr_Occurred()) SWIG_fail;
42114 }
42115 {
42116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42117 }
42118 return resultobj;
42119 fail:
42120 return NULL;
42121 }
42122
42123
42124 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42125 PyObject *resultobj = 0;
42126 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42127 wxString *arg2 = 0 ;
42128 void *argp1 = 0 ;
42129 int res1 = 0 ;
42130 bool temp2 = false ;
42131 PyObject * obj0 = 0 ;
42132 PyObject * obj1 = 0 ;
42133 char * kwnames[] = {
42134 (char *) "self",(char *) "str", NULL
42135 };
42136
42137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42139 if (!SWIG_IsOK(res1)) {
42140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42141 }
42142 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42143 {
42144 arg2 = wxString_in_helper(obj1);
42145 if (arg2 == NULL) SWIG_fail;
42146 temp2 = true;
42147 }
42148 {
42149 PyThreadState* __tstate = wxPyBeginAllowThreads();
42150 (arg1)->SetText((wxString const &)*arg2);
42151 wxPyEndAllowThreads(__tstate);
42152 if (PyErr_Occurred()) SWIG_fail;
42153 }
42154 resultobj = SWIG_Py_Void();
42155 {
42156 if (temp2)
42157 delete arg2;
42158 }
42159 return resultobj;
42160 fail:
42161 {
42162 if (temp2)
42163 delete arg2;
42164 }
42165 return NULL;
42166 }
42167
42168
42169 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42170 PyObject *resultobj = 0;
42171 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42172 wxString result;
42173 void *argp1 = 0 ;
42174 int res1 = 0 ;
42175 PyObject *swig_obj[1] ;
42176
42177 if (!args) SWIG_fail;
42178 swig_obj[0] = args;
42179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42180 if (!SWIG_IsOK(res1)) {
42181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42182 }
42183 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42184 {
42185 PyThreadState* __tstate = wxPyBeginAllowThreads();
42186 result = ((wxMenuItem const *)arg1)->GetLabel();
42187 wxPyEndAllowThreads(__tstate);
42188 if (PyErr_Occurred()) SWIG_fail;
42189 }
42190 {
42191 #if wxUSE_UNICODE
42192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42193 #else
42194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42195 #endif
42196 }
42197 return resultobj;
42198 fail:
42199 return NULL;
42200 }
42201
42202
42203 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42204 PyObject *resultobj = 0;
42205 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42206 wxString *result = 0 ;
42207 void *argp1 = 0 ;
42208 int res1 = 0 ;
42209 PyObject *swig_obj[1] ;
42210
42211 if (!args) SWIG_fail;
42212 swig_obj[0] = args;
42213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42214 if (!SWIG_IsOK(res1)) {
42215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42216 }
42217 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42218 {
42219 PyThreadState* __tstate = wxPyBeginAllowThreads();
42220 {
42221 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42222 result = (wxString *) &_result_ref;
42223 }
42224 wxPyEndAllowThreads(__tstate);
42225 if (PyErr_Occurred()) SWIG_fail;
42226 }
42227 {
42228 #if wxUSE_UNICODE
42229 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42230 #else
42231 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42232 #endif
42233 }
42234 return resultobj;
42235 fail:
42236 return NULL;
42237 }
42238
42239
42240 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42241 PyObject *resultobj = 0;
42242 wxString *arg1 = 0 ;
42243 wxString result;
42244 bool temp1 = false ;
42245 PyObject * obj0 = 0 ;
42246 char * kwnames[] = {
42247 (char *) "text", NULL
42248 };
42249
42250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42251 {
42252 arg1 = wxString_in_helper(obj0);
42253 if (arg1 == NULL) SWIG_fail;
42254 temp1 = true;
42255 }
42256 {
42257 PyThreadState* __tstate = wxPyBeginAllowThreads();
42258 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42259 wxPyEndAllowThreads(__tstate);
42260 if (PyErr_Occurred()) SWIG_fail;
42261 }
42262 {
42263 #if wxUSE_UNICODE
42264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42265 #else
42266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42267 #endif
42268 }
42269 {
42270 if (temp1)
42271 delete arg1;
42272 }
42273 return resultobj;
42274 fail:
42275 {
42276 if (temp1)
42277 delete arg1;
42278 }
42279 return NULL;
42280 }
42281
42282
42283 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42284 PyObject *resultobj = 0;
42285 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42286 wxItemKind result;
42287 void *argp1 = 0 ;
42288 int res1 = 0 ;
42289 PyObject *swig_obj[1] ;
42290
42291 if (!args) SWIG_fail;
42292 swig_obj[0] = args;
42293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42294 if (!SWIG_IsOK(res1)) {
42295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42296 }
42297 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42298 {
42299 PyThreadState* __tstate = wxPyBeginAllowThreads();
42300 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42301 wxPyEndAllowThreads(__tstate);
42302 if (PyErr_Occurred()) SWIG_fail;
42303 }
42304 resultobj = SWIG_From_int(static_cast< int >(result));
42305 return resultobj;
42306 fail:
42307 return NULL;
42308 }
42309
42310
42311 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42312 PyObject *resultobj = 0;
42313 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42314 wxItemKind arg2 ;
42315 void *argp1 = 0 ;
42316 int res1 = 0 ;
42317 int val2 ;
42318 int ecode2 = 0 ;
42319 PyObject * obj0 = 0 ;
42320 PyObject * obj1 = 0 ;
42321 char * kwnames[] = {
42322 (char *) "self",(char *) "kind", NULL
42323 };
42324
42325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42327 if (!SWIG_IsOK(res1)) {
42328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42329 }
42330 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42331 ecode2 = SWIG_AsVal_int(obj1, &val2);
42332 if (!SWIG_IsOK(ecode2)) {
42333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42334 }
42335 arg2 = static_cast< wxItemKind >(val2);
42336 {
42337 PyThreadState* __tstate = wxPyBeginAllowThreads();
42338 (arg1)->SetKind(arg2);
42339 wxPyEndAllowThreads(__tstate);
42340 if (PyErr_Occurred()) SWIG_fail;
42341 }
42342 resultobj = SWIG_Py_Void();
42343 return resultobj;
42344 fail:
42345 return NULL;
42346 }
42347
42348
42349 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42350 PyObject *resultobj = 0;
42351 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42352 bool arg2 ;
42353 void *argp1 = 0 ;
42354 int res1 = 0 ;
42355 bool val2 ;
42356 int ecode2 = 0 ;
42357 PyObject * obj0 = 0 ;
42358 PyObject * obj1 = 0 ;
42359 char * kwnames[] = {
42360 (char *) "self",(char *) "checkable", NULL
42361 };
42362
42363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42365 if (!SWIG_IsOK(res1)) {
42366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42367 }
42368 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42369 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42370 if (!SWIG_IsOK(ecode2)) {
42371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42372 }
42373 arg2 = static_cast< bool >(val2);
42374 {
42375 PyThreadState* __tstate = wxPyBeginAllowThreads();
42376 (arg1)->SetCheckable(arg2);
42377 wxPyEndAllowThreads(__tstate);
42378 if (PyErr_Occurred()) SWIG_fail;
42379 }
42380 resultobj = SWIG_Py_Void();
42381 return resultobj;
42382 fail:
42383 return NULL;
42384 }
42385
42386
42387 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42388 PyObject *resultobj = 0;
42389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42390 bool result;
42391 void *argp1 = 0 ;
42392 int res1 = 0 ;
42393 PyObject *swig_obj[1] ;
42394
42395 if (!args) SWIG_fail;
42396 swig_obj[0] = args;
42397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42398 if (!SWIG_IsOK(res1)) {
42399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42400 }
42401 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42402 {
42403 PyThreadState* __tstate = wxPyBeginAllowThreads();
42404 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42405 wxPyEndAllowThreads(__tstate);
42406 if (PyErr_Occurred()) SWIG_fail;
42407 }
42408 {
42409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42410 }
42411 return resultobj;
42412 fail:
42413 return NULL;
42414 }
42415
42416
42417 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42418 PyObject *resultobj = 0;
42419 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42420 bool result;
42421 void *argp1 = 0 ;
42422 int res1 = 0 ;
42423 PyObject *swig_obj[1] ;
42424
42425 if (!args) SWIG_fail;
42426 swig_obj[0] = args;
42427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42428 if (!SWIG_IsOK(res1)) {
42429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42430 }
42431 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42432 {
42433 PyThreadState* __tstate = wxPyBeginAllowThreads();
42434 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42435 wxPyEndAllowThreads(__tstate);
42436 if (PyErr_Occurred()) SWIG_fail;
42437 }
42438 {
42439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42440 }
42441 return resultobj;
42442 fail:
42443 return NULL;
42444 }
42445
42446
42447 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42448 PyObject *resultobj = 0;
42449 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42450 wxMenu *arg2 = (wxMenu *) 0 ;
42451 void *argp1 = 0 ;
42452 int res1 = 0 ;
42453 void *argp2 = 0 ;
42454 int res2 = 0 ;
42455 PyObject * obj0 = 0 ;
42456 PyObject * obj1 = 0 ;
42457 char * kwnames[] = {
42458 (char *) "self",(char *) "menu", NULL
42459 };
42460
42461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42463 if (!SWIG_IsOK(res1)) {
42464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42465 }
42466 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42467 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42468 if (!SWIG_IsOK(res2)) {
42469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42470 }
42471 arg2 = reinterpret_cast< wxMenu * >(argp2);
42472 {
42473 PyThreadState* __tstate = wxPyBeginAllowThreads();
42474 (arg1)->SetSubMenu(arg2);
42475 wxPyEndAllowThreads(__tstate);
42476 if (PyErr_Occurred()) SWIG_fail;
42477 }
42478 resultobj = SWIG_Py_Void();
42479 return resultobj;
42480 fail:
42481 return NULL;
42482 }
42483
42484
42485 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42486 PyObject *resultobj = 0;
42487 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42488 wxMenu *result = 0 ;
42489 void *argp1 = 0 ;
42490 int res1 = 0 ;
42491 PyObject *swig_obj[1] ;
42492
42493 if (!args) SWIG_fail;
42494 swig_obj[0] = args;
42495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42496 if (!SWIG_IsOK(res1)) {
42497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42498 }
42499 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42500 {
42501 PyThreadState* __tstate = wxPyBeginAllowThreads();
42502 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42503 wxPyEndAllowThreads(__tstate);
42504 if (PyErr_Occurred()) SWIG_fail;
42505 }
42506 {
42507 resultobj = wxPyMake_wxObject(result, 0);
42508 }
42509 return resultobj;
42510 fail:
42511 return NULL;
42512 }
42513
42514
42515 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42516 PyObject *resultobj = 0;
42517 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42518 bool arg2 = (bool) true ;
42519 void *argp1 = 0 ;
42520 int res1 = 0 ;
42521 bool val2 ;
42522 int ecode2 = 0 ;
42523 PyObject * obj0 = 0 ;
42524 PyObject * obj1 = 0 ;
42525 char * kwnames[] = {
42526 (char *) "self",(char *) "enable", NULL
42527 };
42528
42529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42531 if (!SWIG_IsOK(res1)) {
42532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42533 }
42534 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42535 if (obj1) {
42536 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42537 if (!SWIG_IsOK(ecode2)) {
42538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42539 }
42540 arg2 = static_cast< bool >(val2);
42541 }
42542 {
42543 PyThreadState* __tstate = wxPyBeginAllowThreads();
42544 (arg1)->Enable(arg2);
42545 wxPyEndAllowThreads(__tstate);
42546 if (PyErr_Occurred()) SWIG_fail;
42547 }
42548 resultobj = SWIG_Py_Void();
42549 return resultobj;
42550 fail:
42551 return NULL;
42552 }
42553
42554
42555 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42556 PyObject *resultobj = 0;
42557 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42558 bool result;
42559 void *argp1 = 0 ;
42560 int res1 = 0 ;
42561 PyObject *swig_obj[1] ;
42562
42563 if (!args) SWIG_fail;
42564 swig_obj[0] = args;
42565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42566 if (!SWIG_IsOK(res1)) {
42567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42568 }
42569 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42570 {
42571 PyThreadState* __tstate = wxPyBeginAllowThreads();
42572 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42573 wxPyEndAllowThreads(__tstate);
42574 if (PyErr_Occurred()) SWIG_fail;
42575 }
42576 {
42577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42578 }
42579 return resultobj;
42580 fail:
42581 return NULL;
42582 }
42583
42584
42585 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42586 PyObject *resultobj = 0;
42587 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42588 bool arg2 = (bool) true ;
42589 void *argp1 = 0 ;
42590 int res1 = 0 ;
42591 bool val2 ;
42592 int ecode2 = 0 ;
42593 PyObject * obj0 = 0 ;
42594 PyObject * obj1 = 0 ;
42595 char * kwnames[] = {
42596 (char *) "self",(char *) "check", NULL
42597 };
42598
42599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42601 if (!SWIG_IsOK(res1)) {
42602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42603 }
42604 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42605 if (obj1) {
42606 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42607 if (!SWIG_IsOK(ecode2)) {
42608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42609 }
42610 arg2 = static_cast< bool >(val2);
42611 }
42612 {
42613 PyThreadState* __tstate = wxPyBeginAllowThreads();
42614 (arg1)->Check(arg2);
42615 wxPyEndAllowThreads(__tstate);
42616 if (PyErr_Occurred()) SWIG_fail;
42617 }
42618 resultobj = SWIG_Py_Void();
42619 return resultobj;
42620 fail:
42621 return NULL;
42622 }
42623
42624
42625 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42626 PyObject *resultobj = 0;
42627 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42628 bool result;
42629 void *argp1 = 0 ;
42630 int res1 = 0 ;
42631 PyObject *swig_obj[1] ;
42632
42633 if (!args) SWIG_fail;
42634 swig_obj[0] = args;
42635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42636 if (!SWIG_IsOK(res1)) {
42637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42638 }
42639 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42640 {
42641 PyThreadState* __tstate = wxPyBeginAllowThreads();
42642 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42643 wxPyEndAllowThreads(__tstate);
42644 if (PyErr_Occurred()) SWIG_fail;
42645 }
42646 {
42647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42648 }
42649 return resultobj;
42650 fail:
42651 return NULL;
42652 }
42653
42654
42655 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42656 PyObject *resultobj = 0;
42657 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42658 void *argp1 = 0 ;
42659 int res1 = 0 ;
42660 PyObject *swig_obj[1] ;
42661
42662 if (!args) SWIG_fail;
42663 swig_obj[0] = args;
42664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42665 if (!SWIG_IsOK(res1)) {
42666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42667 }
42668 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42669 {
42670 PyThreadState* __tstate = wxPyBeginAllowThreads();
42671 (arg1)->Toggle();
42672 wxPyEndAllowThreads(__tstate);
42673 if (PyErr_Occurred()) SWIG_fail;
42674 }
42675 resultobj = SWIG_Py_Void();
42676 return resultobj;
42677 fail:
42678 return NULL;
42679 }
42680
42681
42682 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42683 PyObject *resultobj = 0;
42684 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42685 wxString *arg2 = 0 ;
42686 void *argp1 = 0 ;
42687 int res1 = 0 ;
42688 bool temp2 = false ;
42689 PyObject * obj0 = 0 ;
42690 PyObject * obj1 = 0 ;
42691 char * kwnames[] = {
42692 (char *) "self",(char *) "str", NULL
42693 };
42694
42695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42697 if (!SWIG_IsOK(res1)) {
42698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42699 }
42700 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42701 {
42702 arg2 = wxString_in_helper(obj1);
42703 if (arg2 == NULL) SWIG_fail;
42704 temp2 = true;
42705 }
42706 {
42707 PyThreadState* __tstate = wxPyBeginAllowThreads();
42708 (arg1)->SetHelp((wxString const &)*arg2);
42709 wxPyEndAllowThreads(__tstate);
42710 if (PyErr_Occurred()) SWIG_fail;
42711 }
42712 resultobj = SWIG_Py_Void();
42713 {
42714 if (temp2)
42715 delete arg2;
42716 }
42717 return resultobj;
42718 fail:
42719 {
42720 if (temp2)
42721 delete arg2;
42722 }
42723 return NULL;
42724 }
42725
42726
42727 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42728 PyObject *resultobj = 0;
42729 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42730 wxString *result = 0 ;
42731 void *argp1 = 0 ;
42732 int res1 = 0 ;
42733 PyObject *swig_obj[1] ;
42734
42735 if (!args) SWIG_fail;
42736 swig_obj[0] = args;
42737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42738 if (!SWIG_IsOK(res1)) {
42739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42740 }
42741 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42742 {
42743 PyThreadState* __tstate = wxPyBeginAllowThreads();
42744 {
42745 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42746 result = (wxString *) &_result_ref;
42747 }
42748 wxPyEndAllowThreads(__tstate);
42749 if (PyErr_Occurred()) SWIG_fail;
42750 }
42751 {
42752 #if wxUSE_UNICODE
42753 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42754 #else
42755 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42756 #endif
42757 }
42758 return resultobj;
42759 fail:
42760 return NULL;
42761 }
42762
42763
42764 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42765 PyObject *resultobj = 0;
42766 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42767 wxAcceleratorEntry *result = 0 ;
42768 void *argp1 = 0 ;
42769 int res1 = 0 ;
42770 PyObject *swig_obj[1] ;
42771
42772 if (!args) SWIG_fail;
42773 swig_obj[0] = args;
42774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42775 if (!SWIG_IsOK(res1)) {
42776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42777 }
42778 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42779 {
42780 PyThreadState* __tstate = wxPyBeginAllowThreads();
42781 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42782 wxPyEndAllowThreads(__tstate);
42783 if (PyErr_Occurred()) SWIG_fail;
42784 }
42785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42786 return resultobj;
42787 fail:
42788 return NULL;
42789 }
42790
42791
42792 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42793 PyObject *resultobj = 0;
42794 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42795 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42796 void *argp1 = 0 ;
42797 int res1 = 0 ;
42798 void *argp2 = 0 ;
42799 int res2 = 0 ;
42800 PyObject * obj0 = 0 ;
42801 PyObject * obj1 = 0 ;
42802 char * kwnames[] = {
42803 (char *) "self",(char *) "accel", NULL
42804 };
42805
42806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42808 if (!SWIG_IsOK(res1)) {
42809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42810 }
42811 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42813 if (!SWIG_IsOK(res2)) {
42814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42815 }
42816 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42817 {
42818 PyThreadState* __tstate = wxPyBeginAllowThreads();
42819 (arg1)->SetAccel(arg2);
42820 wxPyEndAllowThreads(__tstate);
42821 if (PyErr_Occurred()) SWIG_fail;
42822 }
42823 resultobj = SWIG_Py_Void();
42824 return resultobj;
42825 fail:
42826 return NULL;
42827 }
42828
42829
42830 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42831 PyObject *resultobj = 0;
42832 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42833 wxBitmap *arg2 = 0 ;
42834 void *argp1 = 0 ;
42835 int res1 = 0 ;
42836 void *argp2 = 0 ;
42837 int res2 = 0 ;
42838 PyObject * obj0 = 0 ;
42839 PyObject * obj1 = 0 ;
42840 char * kwnames[] = {
42841 (char *) "self",(char *) "bitmap", NULL
42842 };
42843
42844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42846 if (!SWIG_IsOK(res1)) {
42847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42848 }
42849 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42850 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42851 if (!SWIG_IsOK(res2)) {
42852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42853 }
42854 if (!argp2) {
42855 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42856 }
42857 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42858 {
42859 PyThreadState* __tstate = wxPyBeginAllowThreads();
42860 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42861 wxPyEndAllowThreads(__tstate);
42862 if (PyErr_Occurred()) SWIG_fail;
42863 }
42864 resultobj = SWIG_Py_Void();
42865 return resultobj;
42866 fail:
42867 return NULL;
42868 }
42869
42870
42871 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42872 PyObject *resultobj = 0;
42873 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42874 wxBitmap *result = 0 ;
42875 void *argp1 = 0 ;
42876 int res1 = 0 ;
42877 PyObject *swig_obj[1] ;
42878
42879 if (!args) SWIG_fail;
42880 swig_obj[0] = args;
42881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42882 if (!SWIG_IsOK(res1)) {
42883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42884 }
42885 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42886 {
42887 PyThreadState* __tstate = wxPyBeginAllowThreads();
42888 {
42889 wxBitmap const &_result_ref = (arg1)->GetBitmap();
42890 result = (wxBitmap *) &_result_ref;
42891 }
42892 wxPyEndAllowThreads(__tstate);
42893 if (PyErr_Occurred()) SWIG_fail;
42894 }
42895 {
42896 wxBitmap* resultptr = new wxBitmap(*result);
42897 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
42898 }
42899 return resultobj;
42900 fail:
42901 return NULL;
42902 }
42903
42904
42905 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42906 PyObject *resultobj = 0;
42907 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42908 wxFont *arg2 = 0 ;
42909 void *argp1 = 0 ;
42910 int res1 = 0 ;
42911 void *argp2 = 0 ;
42912 int res2 = 0 ;
42913 PyObject * obj0 = 0 ;
42914 PyObject * obj1 = 0 ;
42915 char * kwnames[] = {
42916 (char *) "self",(char *) "font", NULL
42917 };
42918
42919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
42920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42921 if (!SWIG_IsOK(res1)) {
42922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42923 }
42924 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42925 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
42926 if (!SWIG_IsOK(res2)) {
42927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42928 }
42929 if (!argp2) {
42930 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42931 }
42932 arg2 = reinterpret_cast< wxFont * >(argp2);
42933 {
42934 PyThreadState* __tstate = wxPyBeginAllowThreads();
42935 (arg1)->SetFont((wxFont const &)*arg2);
42936 wxPyEndAllowThreads(__tstate);
42937 if (PyErr_Occurred()) SWIG_fail;
42938 }
42939 resultobj = SWIG_Py_Void();
42940 return resultobj;
42941 fail:
42942 return NULL;
42943 }
42944
42945
42946 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42947 PyObject *resultobj = 0;
42948 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42949 wxFont result;
42950 void *argp1 = 0 ;
42951 int res1 = 0 ;
42952 PyObject *swig_obj[1] ;
42953
42954 if (!args) SWIG_fail;
42955 swig_obj[0] = args;
42956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42957 if (!SWIG_IsOK(res1)) {
42958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42959 }
42960 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42961 {
42962 PyThreadState* __tstate = wxPyBeginAllowThreads();
42963 result = (arg1)->GetFont();
42964 wxPyEndAllowThreads(__tstate);
42965 if (PyErr_Occurred()) SWIG_fail;
42966 }
42967 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
42968 return resultobj;
42969 fail:
42970 return NULL;
42971 }
42972
42973
42974 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42975 PyObject *resultobj = 0;
42976 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42977 wxColour *arg2 = 0 ;
42978 void *argp1 = 0 ;
42979 int res1 = 0 ;
42980 wxColour temp2 ;
42981 PyObject * obj0 = 0 ;
42982 PyObject * obj1 = 0 ;
42983 char * kwnames[] = {
42984 (char *) "self",(char *) "colText", NULL
42985 };
42986
42987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
42988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42989 if (!SWIG_IsOK(res1)) {
42990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42991 }
42992 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42993 {
42994 arg2 = &temp2;
42995 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
42996 }
42997 {
42998 PyThreadState* __tstate = wxPyBeginAllowThreads();
42999 (arg1)->SetTextColour((wxColour const &)*arg2);
43000 wxPyEndAllowThreads(__tstate);
43001 if (PyErr_Occurred()) SWIG_fail;
43002 }
43003 resultobj = SWIG_Py_Void();
43004 return resultobj;
43005 fail:
43006 return NULL;
43007 }
43008
43009
43010 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43011 PyObject *resultobj = 0;
43012 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43013 wxColour result;
43014 void *argp1 = 0 ;
43015 int res1 = 0 ;
43016 PyObject *swig_obj[1] ;
43017
43018 if (!args) SWIG_fail;
43019 swig_obj[0] = args;
43020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43021 if (!SWIG_IsOK(res1)) {
43022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43023 }
43024 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43025 {
43026 PyThreadState* __tstate = wxPyBeginAllowThreads();
43027 result = (arg1)->GetTextColour();
43028 wxPyEndAllowThreads(__tstate);
43029 if (PyErr_Occurred()) SWIG_fail;
43030 }
43031 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43032 return resultobj;
43033 fail:
43034 return NULL;
43035 }
43036
43037
43038 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43039 PyObject *resultobj = 0;
43040 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43041 wxColour *arg2 = 0 ;
43042 void *argp1 = 0 ;
43043 int res1 = 0 ;
43044 wxColour temp2 ;
43045 PyObject * obj0 = 0 ;
43046 PyObject * obj1 = 0 ;
43047 char * kwnames[] = {
43048 (char *) "self",(char *) "colBack", NULL
43049 };
43050
43051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43053 if (!SWIG_IsOK(res1)) {
43054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43055 }
43056 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43057 {
43058 arg2 = &temp2;
43059 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43060 }
43061 {
43062 PyThreadState* __tstate = wxPyBeginAllowThreads();
43063 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43064 wxPyEndAllowThreads(__tstate);
43065 if (PyErr_Occurred()) SWIG_fail;
43066 }
43067 resultobj = SWIG_Py_Void();
43068 return resultobj;
43069 fail:
43070 return NULL;
43071 }
43072
43073
43074 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43075 PyObject *resultobj = 0;
43076 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43077 wxColour result;
43078 void *argp1 = 0 ;
43079 int res1 = 0 ;
43080 PyObject *swig_obj[1] ;
43081
43082 if (!args) SWIG_fail;
43083 swig_obj[0] = args;
43084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43085 if (!SWIG_IsOK(res1)) {
43086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43087 }
43088 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43089 {
43090 PyThreadState* __tstate = wxPyBeginAllowThreads();
43091 result = (arg1)->GetBackgroundColour();
43092 wxPyEndAllowThreads(__tstate);
43093 if (PyErr_Occurred()) SWIG_fail;
43094 }
43095 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43096 return resultobj;
43097 fail:
43098 return NULL;
43099 }
43100
43101
43102 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43103 PyObject *resultobj = 0;
43104 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43105 wxBitmap *arg2 = 0 ;
43106 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43107 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43108 void *argp1 = 0 ;
43109 int res1 = 0 ;
43110 void *argp2 = 0 ;
43111 int res2 = 0 ;
43112 void *argp3 = 0 ;
43113 int res3 = 0 ;
43114 PyObject * obj0 = 0 ;
43115 PyObject * obj1 = 0 ;
43116 PyObject * obj2 = 0 ;
43117 char * kwnames[] = {
43118 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43119 };
43120
43121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43123 if (!SWIG_IsOK(res1)) {
43124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43125 }
43126 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43127 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43128 if (!SWIG_IsOK(res2)) {
43129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43130 }
43131 if (!argp2) {
43132 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43133 }
43134 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43135 if (obj2) {
43136 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43137 if (!SWIG_IsOK(res3)) {
43138 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43139 }
43140 if (!argp3) {
43141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43142 }
43143 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43144 }
43145 {
43146 PyThreadState* __tstate = wxPyBeginAllowThreads();
43147 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43148 wxPyEndAllowThreads(__tstate);
43149 if (PyErr_Occurred()) SWIG_fail;
43150 }
43151 resultobj = SWIG_Py_Void();
43152 return resultobj;
43153 fail:
43154 return NULL;
43155 }
43156
43157
43158 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43159 PyObject *resultobj = 0;
43160 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43161 wxBitmap *arg2 = 0 ;
43162 void *argp1 = 0 ;
43163 int res1 = 0 ;
43164 void *argp2 = 0 ;
43165 int res2 = 0 ;
43166 PyObject * obj0 = 0 ;
43167 PyObject * obj1 = 0 ;
43168 char * kwnames[] = {
43169 (char *) "self",(char *) "bmpDisabled", NULL
43170 };
43171
43172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43174 if (!SWIG_IsOK(res1)) {
43175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43176 }
43177 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43178 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43179 if (!SWIG_IsOK(res2)) {
43180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43181 }
43182 if (!argp2) {
43183 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43184 }
43185 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43186 {
43187 PyThreadState* __tstate = wxPyBeginAllowThreads();
43188 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43189 wxPyEndAllowThreads(__tstate);
43190 if (PyErr_Occurred()) SWIG_fail;
43191 }
43192 resultobj = SWIG_Py_Void();
43193 return resultobj;
43194 fail:
43195 return NULL;
43196 }
43197
43198
43199 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43200 PyObject *resultobj = 0;
43201 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43202 wxBitmap *result = 0 ;
43203 void *argp1 = 0 ;
43204 int res1 = 0 ;
43205 PyObject *swig_obj[1] ;
43206
43207 if (!args) SWIG_fail;
43208 swig_obj[0] = args;
43209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43210 if (!SWIG_IsOK(res1)) {
43211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43212 }
43213 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43214 {
43215 PyThreadState* __tstate = wxPyBeginAllowThreads();
43216 {
43217 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43218 result = (wxBitmap *) &_result_ref;
43219 }
43220 wxPyEndAllowThreads(__tstate);
43221 if (PyErr_Occurred()) SWIG_fail;
43222 }
43223 {
43224 wxBitmap* resultptr = new wxBitmap(*result);
43225 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43226 }
43227 return resultobj;
43228 fail:
43229 return NULL;
43230 }
43231
43232
43233 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43234 PyObject *resultobj = 0;
43235 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43236 int arg2 ;
43237 void *argp1 = 0 ;
43238 int res1 = 0 ;
43239 int val2 ;
43240 int ecode2 = 0 ;
43241 PyObject * obj0 = 0 ;
43242 PyObject * obj1 = 0 ;
43243 char * kwnames[] = {
43244 (char *) "self",(char *) "nWidth", NULL
43245 };
43246
43247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43249 if (!SWIG_IsOK(res1)) {
43250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43251 }
43252 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43253 ecode2 = SWIG_AsVal_int(obj1, &val2);
43254 if (!SWIG_IsOK(ecode2)) {
43255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43256 }
43257 arg2 = static_cast< int >(val2);
43258 {
43259 PyThreadState* __tstate = wxPyBeginAllowThreads();
43260 (arg1)->SetMarginWidth(arg2);
43261 wxPyEndAllowThreads(__tstate);
43262 if (PyErr_Occurred()) SWIG_fail;
43263 }
43264 resultobj = SWIG_Py_Void();
43265 return resultobj;
43266 fail:
43267 return NULL;
43268 }
43269
43270
43271 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43272 PyObject *resultobj = 0;
43273 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43274 int result;
43275 void *argp1 = 0 ;
43276 int res1 = 0 ;
43277 PyObject *swig_obj[1] ;
43278
43279 if (!args) SWIG_fail;
43280 swig_obj[0] = args;
43281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43282 if (!SWIG_IsOK(res1)) {
43283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43284 }
43285 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43286 {
43287 PyThreadState* __tstate = wxPyBeginAllowThreads();
43288 result = (int)(arg1)->GetMarginWidth();
43289 wxPyEndAllowThreads(__tstate);
43290 if (PyErr_Occurred()) SWIG_fail;
43291 }
43292 resultobj = SWIG_From_int(static_cast< int >(result));
43293 return resultobj;
43294 fail:
43295 return NULL;
43296 }
43297
43298
43299 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43300 PyObject *resultobj = 0;
43301 int result;
43302
43303 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43304 {
43305 PyThreadState* __tstate = wxPyBeginAllowThreads();
43306 result = (int)wxMenuItem::GetDefaultMarginWidth();
43307 wxPyEndAllowThreads(__tstate);
43308 if (PyErr_Occurred()) SWIG_fail;
43309 }
43310 resultobj = SWIG_From_int(static_cast< int >(result));
43311 return resultobj;
43312 fail:
43313 return NULL;
43314 }
43315
43316
43317 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43318 PyObject *resultobj = 0;
43319 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43320 bool result;
43321 void *argp1 = 0 ;
43322 int res1 = 0 ;
43323 PyObject *swig_obj[1] ;
43324
43325 if (!args) SWIG_fail;
43326 swig_obj[0] = args;
43327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43328 if (!SWIG_IsOK(res1)) {
43329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43330 }
43331 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43332 {
43333 PyThreadState* __tstate = wxPyBeginAllowThreads();
43334 result = (bool)(arg1)->IsOwnerDrawn();
43335 wxPyEndAllowThreads(__tstate);
43336 if (PyErr_Occurred()) SWIG_fail;
43337 }
43338 {
43339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43340 }
43341 return resultobj;
43342 fail:
43343 return NULL;
43344 }
43345
43346
43347 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43348 PyObject *resultobj = 0;
43349 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43350 bool arg2 = (bool) true ;
43351 void *argp1 = 0 ;
43352 int res1 = 0 ;
43353 bool val2 ;
43354 int ecode2 = 0 ;
43355 PyObject * obj0 = 0 ;
43356 PyObject * obj1 = 0 ;
43357 char * kwnames[] = {
43358 (char *) "self",(char *) "ownerDrawn", NULL
43359 };
43360
43361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43363 if (!SWIG_IsOK(res1)) {
43364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43365 }
43366 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43367 if (obj1) {
43368 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43369 if (!SWIG_IsOK(ecode2)) {
43370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43371 }
43372 arg2 = static_cast< bool >(val2);
43373 }
43374 {
43375 PyThreadState* __tstate = wxPyBeginAllowThreads();
43376 (arg1)->SetOwnerDrawn(arg2);
43377 wxPyEndAllowThreads(__tstate);
43378 if (PyErr_Occurred()) SWIG_fail;
43379 }
43380 resultobj = SWIG_Py_Void();
43381 return resultobj;
43382 fail:
43383 return NULL;
43384 }
43385
43386
43387 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43388 PyObject *resultobj = 0;
43389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43390 void *argp1 = 0 ;
43391 int res1 = 0 ;
43392 PyObject *swig_obj[1] ;
43393
43394 if (!args) SWIG_fail;
43395 swig_obj[0] = args;
43396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43397 if (!SWIG_IsOK(res1)) {
43398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43399 }
43400 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43401 {
43402 PyThreadState* __tstate = wxPyBeginAllowThreads();
43403 (arg1)->ResetOwnerDrawn();
43404 wxPyEndAllowThreads(__tstate);
43405 if (PyErr_Occurred()) SWIG_fail;
43406 }
43407 resultobj = SWIG_Py_Void();
43408 return resultobj;
43409 fail:
43410 return NULL;
43411 }
43412
43413
43414 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43415 PyObject *obj;
43416 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43417 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43418 return SWIG_Py_Void();
43419 }
43420
43421 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43422 return SWIG_Python_InitShadowInstance(args);
43423 }
43424
43425 SWIGINTERN int ControlNameStr_set(PyObject *) {
43426 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43427 return 1;
43428 }
43429
43430
43431 SWIGINTERN PyObject *ControlNameStr_get(void) {
43432 PyObject *pyobj = 0;
43433
43434 {
43435 #if wxUSE_UNICODE
43436 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43437 #else
43438 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43439 #endif
43440 }
43441 return pyobj;
43442 }
43443
43444
43445 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43446 PyObject *resultobj = 0;
43447 wxWindow *arg1 = (wxWindow *) 0 ;
43448 int arg2 = (int) -1 ;
43449 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43450 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43451 wxSize const &arg4_defvalue = wxDefaultSize ;
43452 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43453 long arg5 = (long) 0 ;
43454 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43455 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43456 wxString const &arg7_defvalue = wxPyControlNameStr ;
43457 wxString *arg7 = (wxString *) &arg7_defvalue ;
43458 wxControl *result = 0 ;
43459 void *argp1 = 0 ;
43460 int res1 = 0 ;
43461 int val2 ;
43462 int ecode2 = 0 ;
43463 wxPoint temp3 ;
43464 wxSize temp4 ;
43465 long val5 ;
43466 int ecode5 = 0 ;
43467 void *argp6 = 0 ;
43468 int res6 = 0 ;
43469 bool temp7 = false ;
43470 PyObject * obj0 = 0 ;
43471 PyObject * obj1 = 0 ;
43472 PyObject * obj2 = 0 ;
43473 PyObject * obj3 = 0 ;
43474 PyObject * obj4 = 0 ;
43475 PyObject * obj5 = 0 ;
43476 PyObject * obj6 = 0 ;
43477 char * kwnames[] = {
43478 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43479 };
43480
43481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43483 if (!SWIG_IsOK(res1)) {
43484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43485 }
43486 arg1 = reinterpret_cast< wxWindow * >(argp1);
43487 if (obj1) {
43488 ecode2 = SWIG_AsVal_int(obj1, &val2);
43489 if (!SWIG_IsOK(ecode2)) {
43490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43491 }
43492 arg2 = static_cast< int >(val2);
43493 }
43494 if (obj2) {
43495 {
43496 arg3 = &temp3;
43497 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43498 }
43499 }
43500 if (obj3) {
43501 {
43502 arg4 = &temp4;
43503 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43504 }
43505 }
43506 if (obj4) {
43507 ecode5 = SWIG_AsVal_long(obj4, &val5);
43508 if (!SWIG_IsOK(ecode5)) {
43509 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43510 }
43511 arg5 = static_cast< long >(val5);
43512 }
43513 if (obj5) {
43514 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43515 if (!SWIG_IsOK(res6)) {
43516 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43517 }
43518 if (!argp6) {
43519 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43520 }
43521 arg6 = reinterpret_cast< wxValidator * >(argp6);
43522 }
43523 if (obj6) {
43524 {
43525 arg7 = wxString_in_helper(obj6);
43526 if (arg7 == NULL) SWIG_fail;
43527 temp7 = true;
43528 }
43529 }
43530 {
43531 if (!wxPyCheckForApp()) SWIG_fail;
43532 PyThreadState* __tstate = wxPyBeginAllowThreads();
43533 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43534 wxPyEndAllowThreads(__tstate);
43535 if (PyErr_Occurred()) SWIG_fail;
43536 }
43537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43538 {
43539 if (temp7)
43540 delete arg7;
43541 }
43542 return resultobj;
43543 fail:
43544 {
43545 if (temp7)
43546 delete arg7;
43547 }
43548 return NULL;
43549 }
43550
43551
43552 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43553 PyObject *resultobj = 0;
43554 wxControl *result = 0 ;
43555
43556 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43557 {
43558 if (!wxPyCheckForApp()) SWIG_fail;
43559 PyThreadState* __tstate = wxPyBeginAllowThreads();
43560 result = (wxControl *)new wxControl();
43561 wxPyEndAllowThreads(__tstate);
43562 if (PyErr_Occurred()) SWIG_fail;
43563 }
43564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43565 return resultobj;
43566 fail:
43567 return NULL;
43568 }
43569
43570
43571 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43572 PyObject *resultobj = 0;
43573 wxControl *arg1 = (wxControl *) 0 ;
43574 wxWindow *arg2 = (wxWindow *) 0 ;
43575 int arg3 = (int) -1 ;
43576 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43577 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43578 wxSize const &arg5_defvalue = wxDefaultSize ;
43579 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43580 long arg6 = (long) 0 ;
43581 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43582 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43583 wxString const &arg8_defvalue = wxPyControlNameStr ;
43584 wxString *arg8 = (wxString *) &arg8_defvalue ;
43585 bool result;
43586 void *argp1 = 0 ;
43587 int res1 = 0 ;
43588 void *argp2 = 0 ;
43589 int res2 = 0 ;
43590 int val3 ;
43591 int ecode3 = 0 ;
43592 wxPoint temp4 ;
43593 wxSize temp5 ;
43594 long val6 ;
43595 int ecode6 = 0 ;
43596 void *argp7 = 0 ;
43597 int res7 = 0 ;
43598 bool temp8 = false ;
43599 PyObject * obj0 = 0 ;
43600 PyObject * obj1 = 0 ;
43601 PyObject * obj2 = 0 ;
43602 PyObject * obj3 = 0 ;
43603 PyObject * obj4 = 0 ;
43604 PyObject * obj5 = 0 ;
43605 PyObject * obj6 = 0 ;
43606 PyObject * obj7 = 0 ;
43607 char * kwnames[] = {
43608 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43609 };
43610
43611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43613 if (!SWIG_IsOK(res1)) {
43614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43615 }
43616 arg1 = reinterpret_cast< wxControl * >(argp1);
43617 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43618 if (!SWIG_IsOK(res2)) {
43619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43620 }
43621 arg2 = reinterpret_cast< wxWindow * >(argp2);
43622 if (obj2) {
43623 ecode3 = SWIG_AsVal_int(obj2, &val3);
43624 if (!SWIG_IsOK(ecode3)) {
43625 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43626 }
43627 arg3 = static_cast< int >(val3);
43628 }
43629 if (obj3) {
43630 {
43631 arg4 = &temp4;
43632 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43633 }
43634 }
43635 if (obj4) {
43636 {
43637 arg5 = &temp5;
43638 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43639 }
43640 }
43641 if (obj5) {
43642 ecode6 = SWIG_AsVal_long(obj5, &val6);
43643 if (!SWIG_IsOK(ecode6)) {
43644 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43645 }
43646 arg6 = static_cast< long >(val6);
43647 }
43648 if (obj6) {
43649 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43650 if (!SWIG_IsOK(res7)) {
43651 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43652 }
43653 if (!argp7) {
43654 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43655 }
43656 arg7 = reinterpret_cast< wxValidator * >(argp7);
43657 }
43658 if (obj7) {
43659 {
43660 arg8 = wxString_in_helper(obj7);
43661 if (arg8 == NULL) SWIG_fail;
43662 temp8 = true;
43663 }
43664 }
43665 {
43666 PyThreadState* __tstate = wxPyBeginAllowThreads();
43667 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43668 wxPyEndAllowThreads(__tstate);
43669 if (PyErr_Occurred()) SWIG_fail;
43670 }
43671 {
43672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43673 }
43674 {
43675 if (temp8)
43676 delete arg8;
43677 }
43678 return resultobj;
43679 fail:
43680 {
43681 if (temp8)
43682 delete arg8;
43683 }
43684 return NULL;
43685 }
43686
43687
43688 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43689 PyObject *resultobj = 0;
43690 wxControl *arg1 = (wxControl *) 0 ;
43691 wxCommandEvent *arg2 = 0 ;
43692 void *argp1 = 0 ;
43693 int res1 = 0 ;
43694 void *argp2 = 0 ;
43695 int res2 = 0 ;
43696 PyObject * obj0 = 0 ;
43697 PyObject * obj1 = 0 ;
43698 char * kwnames[] = {
43699 (char *) "self",(char *) "event", NULL
43700 };
43701
43702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43704 if (!SWIG_IsOK(res1)) {
43705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43706 }
43707 arg1 = reinterpret_cast< wxControl * >(argp1);
43708 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43709 if (!SWIG_IsOK(res2)) {
43710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43711 }
43712 if (!argp2) {
43713 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43714 }
43715 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43716 {
43717 PyThreadState* __tstate = wxPyBeginAllowThreads();
43718 (arg1)->Command(*arg2);
43719 wxPyEndAllowThreads(__tstate);
43720 if (PyErr_Occurred()) SWIG_fail;
43721 }
43722 resultobj = SWIG_Py_Void();
43723 return resultobj;
43724 fail:
43725 return NULL;
43726 }
43727
43728
43729 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43730 PyObject *resultobj = 0;
43731 wxControl *arg1 = (wxControl *) 0 ;
43732 wxString result;
43733 void *argp1 = 0 ;
43734 int res1 = 0 ;
43735 PyObject *swig_obj[1] ;
43736
43737 if (!args) SWIG_fail;
43738 swig_obj[0] = args;
43739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43740 if (!SWIG_IsOK(res1)) {
43741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43742 }
43743 arg1 = reinterpret_cast< wxControl * >(argp1);
43744 {
43745 PyThreadState* __tstate = wxPyBeginAllowThreads();
43746 result = (arg1)->GetLabel();
43747 wxPyEndAllowThreads(__tstate);
43748 if (PyErr_Occurred()) SWIG_fail;
43749 }
43750 {
43751 #if wxUSE_UNICODE
43752 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43753 #else
43754 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43755 #endif
43756 }
43757 return resultobj;
43758 fail:
43759 return NULL;
43760 }
43761
43762
43763 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43764 PyObject *resultobj = 0;
43765 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43766 SwigValueWrapper<wxVisualAttributes > result;
43767 int val1 ;
43768 int ecode1 = 0 ;
43769 PyObject * obj0 = 0 ;
43770 char * kwnames[] = {
43771 (char *) "variant", NULL
43772 };
43773
43774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43775 if (obj0) {
43776 ecode1 = SWIG_AsVal_int(obj0, &val1);
43777 if (!SWIG_IsOK(ecode1)) {
43778 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43779 }
43780 arg1 = static_cast< wxWindowVariant >(val1);
43781 }
43782 {
43783 if (!wxPyCheckForApp()) SWIG_fail;
43784 PyThreadState* __tstate = wxPyBeginAllowThreads();
43785 result = wxControl::GetClassDefaultAttributes(arg1);
43786 wxPyEndAllowThreads(__tstate);
43787 if (PyErr_Occurred()) SWIG_fail;
43788 }
43789 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43790 return resultobj;
43791 fail:
43792 return NULL;
43793 }
43794
43795
43796 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43797 PyObject *obj;
43798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43799 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43800 return SWIG_Py_Void();
43801 }
43802
43803 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43804 return SWIG_Python_InitShadowInstance(args);
43805 }
43806
43807 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43808 PyObject *resultobj = 0;
43809 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43810 wxString *arg2 = 0 ;
43811 PyObject *arg3 = (PyObject *) NULL ;
43812 int result;
43813 void *argp1 = 0 ;
43814 int res1 = 0 ;
43815 bool temp2 = false ;
43816 PyObject * obj0 = 0 ;
43817 PyObject * obj1 = 0 ;
43818 PyObject * obj2 = 0 ;
43819 char * kwnames[] = {
43820 (char *) "self",(char *) "item",(char *) "clientData", NULL
43821 };
43822
43823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43825 if (!SWIG_IsOK(res1)) {
43826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43827 }
43828 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43829 {
43830 arg2 = wxString_in_helper(obj1);
43831 if (arg2 == NULL) SWIG_fail;
43832 temp2 = true;
43833 }
43834 if (obj2) {
43835 arg3 = obj2;
43836 }
43837 {
43838 PyThreadState* __tstate = wxPyBeginAllowThreads();
43839 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43840 wxPyEndAllowThreads(__tstate);
43841 if (PyErr_Occurred()) SWIG_fail;
43842 }
43843 resultobj = SWIG_From_int(static_cast< int >(result));
43844 {
43845 if (temp2)
43846 delete arg2;
43847 }
43848 return resultobj;
43849 fail:
43850 {
43851 if (temp2)
43852 delete arg2;
43853 }
43854 return NULL;
43855 }
43856
43857
43858 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43859 PyObject *resultobj = 0;
43860 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43861 wxArrayString *arg2 = 0 ;
43862 void *argp1 = 0 ;
43863 int res1 = 0 ;
43864 bool temp2 = false ;
43865 PyObject * obj0 = 0 ;
43866 PyObject * obj1 = 0 ;
43867 char * kwnames[] = {
43868 (char *) "self",(char *) "strings", NULL
43869 };
43870
43871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43873 if (!SWIG_IsOK(res1)) {
43874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43875 }
43876 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43877 {
43878 if (! PySequence_Check(obj1)) {
43879 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43880 SWIG_fail;
43881 }
43882 arg2 = new wxArrayString;
43883 temp2 = true;
43884 int i, len=PySequence_Length(obj1);
43885 for (i=0; i<len; i++) {
43886 PyObject* item = PySequence_GetItem(obj1, i);
43887 wxString* s = wxString_in_helper(item);
43888 if (PyErr_Occurred()) SWIG_fail;
43889 arg2->Add(*s);
43890 delete s;
43891 Py_DECREF(item);
43892 }
43893 }
43894 {
43895 PyThreadState* __tstate = wxPyBeginAllowThreads();
43896 (arg1)->Append((wxArrayString const &)*arg2);
43897 wxPyEndAllowThreads(__tstate);
43898 if (PyErr_Occurred()) SWIG_fail;
43899 }
43900 resultobj = SWIG_Py_Void();
43901 {
43902 if (temp2) delete arg2;
43903 }
43904 return resultobj;
43905 fail:
43906 {
43907 if (temp2) delete arg2;
43908 }
43909 return NULL;
43910 }
43911
43912
43913 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43914 PyObject *resultobj = 0;
43915 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43916 wxString *arg2 = 0 ;
43917 unsigned int arg3 ;
43918 PyObject *arg4 = (PyObject *) NULL ;
43919 int result;
43920 void *argp1 = 0 ;
43921 int res1 = 0 ;
43922 bool temp2 = false ;
43923 unsigned int val3 ;
43924 int ecode3 = 0 ;
43925 PyObject * obj0 = 0 ;
43926 PyObject * obj1 = 0 ;
43927 PyObject * obj2 = 0 ;
43928 PyObject * obj3 = 0 ;
43929 char * kwnames[] = {
43930 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
43931 };
43932
43933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43935 if (!SWIG_IsOK(res1)) {
43936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43937 }
43938 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43939 {
43940 arg2 = wxString_in_helper(obj1);
43941 if (arg2 == NULL) SWIG_fail;
43942 temp2 = true;
43943 }
43944 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
43945 if (!SWIG_IsOK(ecode3)) {
43946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
43947 }
43948 arg3 = static_cast< unsigned int >(val3);
43949 if (obj3) {
43950 arg4 = obj3;
43951 }
43952 {
43953 PyThreadState* __tstate = wxPyBeginAllowThreads();
43954 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
43955 wxPyEndAllowThreads(__tstate);
43956 if (PyErr_Occurred()) SWIG_fail;
43957 }
43958 resultobj = SWIG_From_int(static_cast< int >(result));
43959 {
43960 if (temp2)
43961 delete arg2;
43962 }
43963 return resultobj;
43964 fail:
43965 {
43966 if (temp2)
43967 delete arg2;
43968 }
43969 return NULL;
43970 }
43971
43972
43973 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43974 PyObject *resultobj = 0;
43975 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43976 void *argp1 = 0 ;
43977 int res1 = 0 ;
43978 PyObject *swig_obj[1] ;
43979
43980 if (!args) SWIG_fail;
43981 swig_obj[0] = args;
43982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43983 if (!SWIG_IsOK(res1)) {
43984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43985 }
43986 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43987 {
43988 PyThreadState* __tstate = wxPyBeginAllowThreads();
43989 (arg1)->Clear();
43990 wxPyEndAllowThreads(__tstate);
43991 if (PyErr_Occurred()) SWIG_fail;
43992 }
43993 resultobj = SWIG_Py_Void();
43994 return resultobj;
43995 fail:
43996 return NULL;
43997 }
43998
43999
44000 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44001 PyObject *resultobj = 0;
44002 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44003 unsigned int arg2 ;
44004 void *argp1 = 0 ;
44005 int res1 = 0 ;
44006 unsigned int val2 ;
44007 int ecode2 = 0 ;
44008 PyObject * obj0 = 0 ;
44009 PyObject * obj1 = 0 ;
44010 char * kwnames[] = {
44011 (char *) "self",(char *) "n", NULL
44012 };
44013
44014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44016 if (!SWIG_IsOK(res1)) {
44017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44018 }
44019 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44020 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44021 if (!SWIG_IsOK(ecode2)) {
44022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44023 }
44024 arg2 = static_cast< unsigned int >(val2);
44025 {
44026 PyThreadState* __tstate = wxPyBeginAllowThreads();
44027 (arg1)->Delete(arg2);
44028 wxPyEndAllowThreads(__tstate);
44029 if (PyErr_Occurred()) SWIG_fail;
44030 }
44031 resultobj = SWIG_Py_Void();
44032 return resultobj;
44033 fail:
44034 return NULL;
44035 }
44036
44037
44038 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44039 PyObject *resultobj = 0;
44040 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44041 unsigned int arg2 ;
44042 PyObject *result = 0 ;
44043 void *argp1 = 0 ;
44044 int res1 = 0 ;
44045 unsigned int val2 ;
44046 int ecode2 = 0 ;
44047 PyObject * obj0 = 0 ;
44048 PyObject * obj1 = 0 ;
44049 char * kwnames[] = {
44050 (char *) "self",(char *) "n", NULL
44051 };
44052
44053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44055 if (!SWIG_IsOK(res1)) {
44056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44057 }
44058 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44059 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44060 if (!SWIG_IsOK(ecode2)) {
44061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44062 }
44063 arg2 = static_cast< unsigned int >(val2);
44064 {
44065 PyThreadState* __tstate = wxPyBeginAllowThreads();
44066 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44067 wxPyEndAllowThreads(__tstate);
44068 if (PyErr_Occurred()) SWIG_fail;
44069 }
44070 resultobj = result;
44071 return resultobj;
44072 fail:
44073 return NULL;
44074 }
44075
44076
44077 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44078 PyObject *resultobj = 0;
44079 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44080 unsigned int arg2 ;
44081 PyObject *arg3 = (PyObject *) 0 ;
44082 void *argp1 = 0 ;
44083 int res1 = 0 ;
44084 unsigned int val2 ;
44085 int ecode2 = 0 ;
44086 PyObject * obj0 = 0 ;
44087 PyObject * obj1 = 0 ;
44088 PyObject * obj2 = 0 ;
44089 char * kwnames[] = {
44090 (char *) "self",(char *) "n",(char *) "clientData", NULL
44091 };
44092
44093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44095 if (!SWIG_IsOK(res1)) {
44096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44097 }
44098 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44099 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44100 if (!SWIG_IsOK(ecode2)) {
44101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44102 }
44103 arg2 = static_cast< unsigned int >(val2);
44104 arg3 = obj2;
44105 {
44106 PyThreadState* __tstate = wxPyBeginAllowThreads();
44107 wxItemContainer_SetClientData(arg1,arg2,arg3);
44108 wxPyEndAllowThreads(__tstate);
44109 if (PyErr_Occurred()) SWIG_fail;
44110 }
44111 resultobj = SWIG_Py_Void();
44112 return resultobj;
44113 fail:
44114 return NULL;
44115 }
44116
44117
44118 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44119 PyObject *resultobj = 0;
44120 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44121 unsigned int result;
44122 void *argp1 = 0 ;
44123 int res1 = 0 ;
44124 PyObject *swig_obj[1] ;
44125
44126 if (!args) SWIG_fail;
44127 swig_obj[0] = args;
44128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44129 if (!SWIG_IsOK(res1)) {
44130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44131 }
44132 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44133 {
44134 PyThreadState* __tstate = wxPyBeginAllowThreads();
44135 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44136 wxPyEndAllowThreads(__tstate);
44137 if (PyErr_Occurred()) SWIG_fail;
44138 }
44139 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44140 return resultobj;
44141 fail:
44142 return NULL;
44143 }
44144
44145
44146 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44147 PyObject *resultobj = 0;
44148 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44149 bool result;
44150 void *argp1 = 0 ;
44151 int res1 = 0 ;
44152 PyObject *swig_obj[1] ;
44153
44154 if (!args) SWIG_fail;
44155 swig_obj[0] = args;
44156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44157 if (!SWIG_IsOK(res1)) {
44158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44159 }
44160 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44161 {
44162 PyThreadState* __tstate = wxPyBeginAllowThreads();
44163 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44164 wxPyEndAllowThreads(__tstate);
44165 if (PyErr_Occurred()) SWIG_fail;
44166 }
44167 {
44168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44169 }
44170 return resultobj;
44171 fail:
44172 return NULL;
44173 }
44174
44175
44176 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44177 PyObject *resultobj = 0;
44178 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44179 unsigned int arg2 ;
44180 wxString result;
44181 void *argp1 = 0 ;
44182 int res1 = 0 ;
44183 unsigned int val2 ;
44184 int ecode2 = 0 ;
44185 PyObject * obj0 = 0 ;
44186 PyObject * obj1 = 0 ;
44187 char * kwnames[] = {
44188 (char *) "self",(char *) "n", NULL
44189 };
44190
44191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44193 if (!SWIG_IsOK(res1)) {
44194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44195 }
44196 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44197 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44198 if (!SWIG_IsOK(ecode2)) {
44199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44200 }
44201 arg2 = static_cast< unsigned int >(val2);
44202 {
44203 PyThreadState* __tstate = wxPyBeginAllowThreads();
44204 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44205 wxPyEndAllowThreads(__tstate);
44206 if (PyErr_Occurred()) SWIG_fail;
44207 }
44208 {
44209 #if wxUSE_UNICODE
44210 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44211 #else
44212 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44213 #endif
44214 }
44215 return resultobj;
44216 fail:
44217 return NULL;
44218 }
44219
44220
44221 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44222 PyObject *resultobj = 0;
44223 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44224 wxArrayString result;
44225 void *argp1 = 0 ;
44226 int res1 = 0 ;
44227 PyObject *swig_obj[1] ;
44228
44229 if (!args) SWIG_fail;
44230 swig_obj[0] = args;
44231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44232 if (!SWIG_IsOK(res1)) {
44233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44234 }
44235 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44236 {
44237 PyThreadState* __tstate = wxPyBeginAllowThreads();
44238 result = ((wxItemContainer const *)arg1)->GetStrings();
44239 wxPyEndAllowThreads(__tstate);
44240 if (PyErr_Occurred()) SWIG_fail;
44241 }
44242 {
44243 resultobj = wxArrayString2PyList_helper(result);
44244 }
44245 return resultobj;
44246 fail:
44247 return NULL;
44248 }
44249
44250
44251 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44252 PyObject *resultobj = 0;
44253 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44254 unsigned int arg2 ;
44255 wxString *arg3 = 0 ;
44256 void *argp1 = 0 ;
44257 int res1 = 0 ;
44258 unsigned int val2 ;
44259 int ecode2 = 0 ;
44260 bool temp3 = false ;
44261 PyObject * obj0 = 0 ;
44262 PyObject * obj1 = 0 ;
44263 PyObject * obj2 = 0 ;
44264 char * kwnames[] = {
44265 (char *) "self",(char *) "n",(char *) "s", NULL
44266 };
44267
44268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44270 if (!SWIG_IsOK(res1)) {
44271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44272 }
44273 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44274 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44275 if (!SWIG_IsOK(ecode2)) {
44276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44277 }
44278 arg2 = static_cast< unsigned int >(val2);
44279 {
44280 arg3 = wxString_in_helper(obj2);
44281 if (arg3 == NULL) SWIG_fail;
44282 temp3 = true;
44283 }
44284 {
44285 PyThreadState* __tstate = wxPyBeginAllowThreads();
44286 (arg1)->SetString(arg2,(wxString const &)*arg3);
44287 wxPyEndAllowThreads(__tstate);
44288 if (PyErr_Occurred()) SWIG_fail;
44289 }
44290 resultobj = SWIG_Py_Void();
44291 {
44292 if (temp3)
44293 delete arg3;
44294 }
44295 return resultobj;
44296 fail:
44297 {
44298 if (temp3)
44299 delete arg3;
44300 }
44301 return NULL;
44302 }
44303
44304
44305 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44306 PyObject *resultobj = 0;
44307 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44308 wxString *arg2 = 0 ;
44309 int result;
44310 void *argp1 = 0 ;
44311 int res1 = 0 ;
44312 bool temp2 = false ;
44313 PyObject * obj0 = 0 ;
44314 PyObject * obj1 = 0 ;
44315 char * kwnames[] = {
44316 (char *) "self",(char *) "s", NULL
44317 };
44318
44319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44321 if (!SWIG_IsOK(res1)) {
44322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44323 }
44324 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44325 {
44326 arg2 = wxString_in_helper(obj1);
44327 if (arg2 == NULL) SWIG_fail;
44328 temp2 = true;
44329 }
44330 {
44331 PyThreadState* __tstate = wxPyBeginAllowThreads();
44332 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44333 wxPyEndAllowThreads(__tstate);
44334 if (PyErr_Occurred()) SWIG_fail;
44335 }
44336 resultobj = SWIG_From_int(static_cast< int >(result));
44337 {
44338 if (temp2)
44339 delete arg2;
44340 }
44341 return resultobj;
44342 fail:
44343 {
44344 if (temp2)
44345 delete arg2;
44346 }
44347 return NULL;
44348 }
44349
44350
44351 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44352 PyObject *resultobj = 0;
44353 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44354 int arg2 ;
44355 void *argp1 = 0 ;
44356 int res1 = 0 ;
44357 int val2 ;
44358 int ecode2 = 0 ;
44359 PyObject * obj0 = 0 ;
44360 PyObject * obj1 = 0 ;
44361 char * kwnames[] = {
44362 (char *) "self",(char *) "n", NULL
44363 };
44364
44365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44367 if (!SWIG_IsOK(res1)) {
44368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44369 }
44370 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44371 ecode2 = SWIG_AsVal_int(obj1, &val2);
44372 if (!SWIG_IsOK(ecode2)) {
44373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44374 }
44375 arg2 = static_cast< int >(val2);
44376 {
44377 PyThreadState* __tstate = wxPyBeginAllowThreads();
44378 (arg1)->SetSelection(arg2);
44379 wxPyEndAllowThreads(__tstate);
44380 if (PyErr_Occurred()) SWIG_fail;
44381 }
44382 resultobj = SWIG_Py_Void();
44383 return resultobj;
44384 fail:
44385 return NULL;
44386 }
44387
44388
44389 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44390 PyObject *resultobj = 0;
44391 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44392 int result;
44393 void *argp1 = 0 ;
44394 int res1 = 0 ;
44395 PyObject *swig_obj[1] ;
44396
44397 if (!args) SWIG_fail;
44398 swig_obj[0] = args;
44399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44400 if (!SWIG_IsOK(res1)) {
44401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44402 }
44403 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44404 {
44405 PyThreadState* __tstate = wxPyBeginAllowThreads();
44406 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44407 wxPyEndAllowThreads(__tstate);
44408 if (PyErr_Occurred()) SWIG_fail;
44409 }
44410 resultobj = SWIG_From_int(static_cast< int >(result));
44411 return resultobj;
44412 fail:
44413 return NULL;
44414 }
44415
44416
44417 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44418 PyObject *resultobj = 0;
44419 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44420 wxString *arg2 = 0 ;
44421 bool result;
44422 void *argp1 = 0 ;
44423 int res1 = 0 ;
44424 bool temp2 = false ;
44425 PyObject * obj0 = 0 ;
44426 PyObject * obj1 = 0 ;
44427 char * kwnames[] = {
44428 (char *) "self",(char *) "s", NULL
44429 };
44430
44431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44433 if (!SWIG_IsOK(res1)) {
44434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44435 }
44436 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44437 {
44438 arg2 = wxString_in_helper(obj1);
44439 if (arg2 == NULL) SWIG_fail;
44440 temp2 = true;
44441 }
44442 {
44443 PyThreadState* __tstate = wxPyBeginAllowThreads();
44444 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44445 wxPyEndAllowThreads(__tstate);
44446 if (PyErr_Occurred()) SWIG_fail;
44447 }
44448 {
44449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44450 }
44451 {
44452 if (temp2)
44453 delete arg2;
44454 }
44455 return resultobj;
44456 fail:
44457 {
44458 if (temp2)
44459 delete arg2;
44460 }
44461 return NULL;
44462 }
44463
44464
44465 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44466 PyObject *resultobj = 0;
44467 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44468 wxString result;
44469 void *argp1 = 0 ;
44470 int res1 = 0 ;
44471 PyObject *swig_obj[1] ;
44472
44473 if (!args) SWIG_fail;
44474 swig_obj[0] = args;
44475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44476 if (!SWIG_IsOK(res1)) {
44477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44478 }
44479 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44480 {
44481 PyThreadState* __tstate = wxPyBeginAllowThreads();
44482 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44483 wxPyEndAllowThreads(__tstate);
44484 if (PyErr_Occurred()) SWIG_fail;
44485 }
44486 {
44487 #if wxUSE_UNICODE
44488 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44489 #else
44490 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44491 #endif
44492 }
44493 return resultobj;
44494 fail:
44495 return NULL;
44496 }
44497
44498
44499 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44500 PyObject *resultobj = 0;
44501 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44502 int arg2 ;
44503 void *argp1 = 0 ;
44504 int res1 = 0 ;
44505 int val2 ;
44506 int ecode2 = 0 ;
44507 PyObject * obj0 = 0 ;
44508 PyObject * obj1 = 0 ;
44509 char * kwnames[] = {
44510 (char *) "self",(char *) "n", NULL
44511 };
44512
44513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44515 if (!SWIG_IsOK(res1)) {
44516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44517 }
44518 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44519 ecode2 = SWIG_AsVal_int(obj1, &val2);
44520 if (!SWIG_IsOK(ecode2)) {
44521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44522 }
44523 arg2 = static_cast< int >(val2);
44524 {
44525 PyThreadState* __tstate = wxPyBeginAllowThreads();
44526 (arg1)->Select(arg2);
44527 wxPyEndAllowThreads(__tstate);
44528 if (PyErr_Occurred()) SWIG_fail;
44529 }
44530 resultobj = SWIG_Py_Void();
44531 return resultobj;
44532 fail:
44533 return NULL;
44534 }
44535
44536
44537 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44538 PyObject *obj;
44539 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44540 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44541 return SWIG_Py_Void();
44542 }
44543
44544 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44545 PyObject *obj;
44546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44547 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44548 return SWIG_Py_Void();
44549 }
44550
44551 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44552 PyObject *resultobj = 0;
44553 wxSizerItem *result = 0 ;
44554
44555 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44556 {
44557 PyThreadState* __tstate = wxPyBeginAllowThreads();
44558 result = (wxSizerItem *)new wxSizerItem();
44559 wxPyEndAllowThreads(__tstate);
44560 if (PyErr_Occurred()) SWIG_fail;
44561 }
44562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44563 return resultobj;
44564 fail:
44565 return NULL;
44566 }
44567
44568
44569 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44570 PyObject *resultobj = 0;
44571 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44572 void *argp1 = 0 ;
44573 int res1 = 0 ;
44574 PyObject *swig_obj[1] ;
44575
44576 if (!args) SWIG_fail;
44577 swig_obj[0] = args;
44578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44579 if (!SWIG_IsOK(res1)) {
44580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44581 }
44582 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44583 {
44584 PyThreadState* __tstate = wxPyBeginAllowThreads();
44585 delete arg1;
44586
44587 wxPyEndAllowThreads(__tstate);
44588 if (PyErr_Occurred()) SWIG_fail;
44589 }
44590 resultobj = SWIG_Py_Void();
44591 return resultobj;
44592 fail:
44593 return NULL;
44594 }
44595
44596
44597 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44598 PyObject *resultobj = 0;
44599 wxWindow *arg1 = (wxWindow *) 0 ;
44600 int arg2 ;
44601 int arg3 ;
44602 int arg4 ;
44603 PyObject *arg5 = (PyObject *) NULL ;
44604 wxSizerItem *result = 0 ;
44605 void *argp1 = 0 ;
44606 int res1 = 0 ;
44607 int val2 ;
44608 int ecode2 = 0 ;
44609 int val3 ;
44610 int ecode3 = 0 ;
44611 int val4 ;
44612 int ecode4 = 0 ;
44613 PyObject * obj0 = 0 ;
44614 PyObject * obj1 = 0 ;
44615 PyObject * obj2 = 0 ;
44616 PyObject * obj3 = 0 ;
44617 PyObject * obj4 = 0 ;
44618 char * kwnames[] = {
44619 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44620 };
44621
44622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44624 if (!SWIG_IsOK(res1)) {
44625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44626 }
44627 arg1 = reinterpret_cast< wxWindow * >(argp1);
44628 ecode2 = SWIG_AsVal_int(obj1, &val2);
44629 if (!SWIG_IsOK(ecode2)) {
44630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44631 }
44632 arg2 = static_cast< int >(val2);
44633 ecode3 = SWIG_AsVal_int(obj2, &val3);
44634 if (!SWIG_IsOK(ecode3)) {
44635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44636 }
44637 arg3 = static_cast< int >(val3);
44638 ecode4 = SWIG_AsVal_int(obj3, &val4);
44639 if (!SWIG_IsOK(ecode4)) {
44640 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44641 }
44642 arg4 = static_cast< int >(val4);
44643 if (obj4) {
44644 arg5 = obj4;
44645 }
44646 {
44647 PyThreadState* __tstate = wxPyBeginAllowThreads();
44648 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44649 wxPyEndAllowThreads(__tstate);
44650 if (PyErr_Occurred()) SWIG_fail;
44651 }
44652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44653 return resultobj;
44654 fail:
44655 return NULL;
44656 }
44657
44658
44659 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44660 PyObject *resultobj = 0;
44661 int arg1 ;
44662 int arg2 ;
44663 int arg3 ;
44664 int arg4 ;
44665 int arg5 ;
44666 PyObject *arg6 = (PyObject *) NULL ;
44667 wxSizerItem *result = 0 ;
44668 int val1 ;
44669 int ecode1 = 0 ;
44670 int val2 ;
44671 int ecode2 = 0 ;
44672 int val3 ;
44673 int ecode3 = 0 ;
44674 int val4 ;
44675 int ecode4 = 0 ;
44676 int val5 ;
44677 int ecode5 = 0 ;
44678 PyObject * obj0 = 0 ;
44679 PyObject * obj1 = 0 ;
44680 PyObject * obj2 = 0 ;
44681 PyObject * obj3 = 0 ;
44682 PyObject * obj4 = 0 ;
44683 PyObject * obj5 = 0 ;
44684 char * kwnames[] = {
44685 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44686 };
44687
44688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44689 ecode1 = SWIG_AsVal_int(obj0, &val1);
44690 if (!SWIG_IsOK(ecode1)) {
44691 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44692 }
44693 arg1 = static_cast< int >(val1);
44694 ecode2 = SWIG_AsVal_int(obj1, &val2);
44695 if (!SWIG_IsOK(ecode2)) {
44696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44697 }
44698 arg2 = static_cast< int >(val2);
44699 ecode3 = SWIG_AsVal_int(obj2, &val3);
44700 if (!SWIG_IsOK(ecode3)) {
44701 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44702 }
44703 arg3 = static_cast< int >(val3);
44704 ecode4 = SWIG_AsVal_int(obj3, &val4);
44705 if (!SWIG_IsOK(ecode4)) {
44706 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44707 }
44708 arg4 = static_cast< int >(val4);
44709 ecode5 = SWIG_AsVal_int(obj4, &val5);
44710 if (!SWIG_IsOK(ecode5)) {
44711 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44712 }
44713 arg5 = static_cast< int >(val5);
44714 if (obj5) {
44715 arg6 = obj5;
44716 }
44717 {
44718 PyThreadState* __tstate = wxPyBeginAllowThreads();
44719 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44720 wxPyEndAllowThreads(__tstate);
44721 if (PyErr_Occurred()) SWIG_fail;
44722 }
44723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44724 return resultobj;
44725 fail:
44726 return NULL;
44727 }
44728
44729
44730 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44731 PyObject *resultobj = 0;
44732 wxSizer *arg1 = (wxSizer *) 0 ;
44733 int arg2 ;
44734 int arg3 ;
44735 int arg4 ;
44736 PyObject *arg5 = (PyObject *) NULL ;
44737 wxSizerItem *result = 0 ;
44738 int res1 = 0 ;
44739 int val2 ;
44740 int ecode2 = 0 ;
44741 int val3 ;
44742 int ecode3 = 0 ;
44743 int val4 ;
44744 int ecode4 = 0 ;
44745 PyObject * obj0 = 0 ;
44746 PyObject * obj1 = 0 ;
44747 PyObject * obj2 = 0 ;
44748 PyObject * obj3 = 0 ;
44749 PyObject * obj4 = 0 ;
44750 char * kwnames[] = {
44751 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44752 };
44753
44754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44755 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44756 if (!SWIG_IsOK(res1)) {
44757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44758 }
44759 ecode2 = SWIG_AsVal_int(obj1, &val2);
44760 if (!SWIG_IsOK(ecode2)) {
44761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44762 }
44763 arg2 = static_cast< int >(val2);
44764 ecode3 = SWIG_AsVal_int(obj2, &val3);
44765 if (!SWIG_IsOK(ecode3)) {
44766 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44767 }
44768 arg3 = static_cast< int >(val3);
44769 ecode4 = SWIG_AsVal_int(obj3, &val4);
44770 if (!SWIG_IsOK(ecode4)) {
44771 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44772 }
44773 arg4 = static_cast< int >(val4);
44774 if (obj4) {
44775 arg5 = obj4;
44776 }
44777 {
44778 PyThreadState* __tstate = wxPyBeginAllowThreads();
44779 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44780 wxPyEndAllowThreads(__tstate);
44781 if (PyErr_Occurred()) SWIG_fail;
44782 }
44783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44784 return resultobj;
44785 fail:
44786 return NULL;
44787 }
44788
44789
44790 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44791 PyObject *resultobj = 0;
44792 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44793 void *argp1 = 0 ;
44794 int res1 = 0 ;
44795 PyObject *swig_obj[1] ;
44796
44797 if (!args) SWIG_fail;
44798 swig_obj[0] = args;
44799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44800 if (!SWIG_IsOK(res1)) {
44801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44802 }
44803 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44804 {
44805 PyThreadState* __tstate = wxPyBeginAllowThreads();
44806 (arg1)->DeleteWindows();
44807 wxPyEndAllowThreads(__tstate);
44808 if (PyErr_Occurred()) SWIG_fail;
44809 }
44810 resultobj = SWIG_Py_Void();
44811 return resultobj;
44812 fail:
44813 return NULL;
44814 }
44815
44816
44817 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44818 PyObject *resultobj = 0;
44819 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44820 void *argp1 = 0 ;
44821 int res1 = 0 ;
44822 PyObject *swig_obj[1] ;
44823
44824 if (!args) SWIG_fail;
44825 swig_obj[0] = args;
44826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44827 if (!SWIG_IsOK(res1)) {
44828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44829 }
44830 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44831 {
44832 PyThreadState* __tstate = wxPyBeginAllowThreads();
44833 (arg1)->DetachSizer();
44834 wxPyEndAllowThreads(__tstate);
44835 if (PyErr_Occurred()) SWIG_fail;
44836 }
44837 resultobj = SWIG_Py_Void();
44838 return resultobj;
44839 fail:
44840 return NULL;
44841 }
44842
44843
44844 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44845 PyObject *resultobj = 0;
44846 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44847 wxSize result;
44848 void *argp1 = 0 ;
44849 int res1 = 0 ;
44850 PyObject *swig_obj[1] ;
44851
44852 if (!args) SWIG_fail;
44853 swig_obj[0] = args;
44854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44855 if (!SWIG_IsOK(res1)) {
44856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44857 }
44858 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44859 {
44860 PyThreadState* __tstate = wxPyBeginAllowThreads();
44861 result = (arg1)->GetSize();
44862 wxPyEndAllowThreads(__tstate);
44863 if (PyErr_Occurred()) SWIG_fail;
44864 }
44865 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44866 return resultobj;
44867 fail:
44868 return NULL;
44869 }
44870
44871
44872 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44873 PyObject *resultobj = 0;
44874 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44875 wxSize result;
44876 void *argp1 = 0 ;
44877 int res1 = 0 ;
44878 PyObject *swig_obj[1] ;
44879
44880 if (!args) SWIG_fail;
44881 swig_obj[0] = args;
44882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44883 if (!SWIG_IsOK(res1)) {
44884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44885 }
44886 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44887 {
44888 PyThreadState* __tstate = wxPyBeginAllowThreads();
44889 result = (arg1)->CalcMin();
44890 wxPyEndAllowThreads(__tstate);
44891 if (PyErr_Occurred()) SWIG_fail;
44892 }
44893 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44894 return resultobj;
44895 fail:
44896 return NULL;
44897 }
44898
44899
44900 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44901 PyObject *resultobj = 0;
44902 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44903 wxPoint *arg2 = 0 ;
44904 wxSize *arg3 = 0 ;
44905 void *argp1 = 0 ;
44906 int res1 = 0 ;
44907 wxPoint temp2 ;
44908 wxSize temp3 ;
44909 PyObject * obj0 = 0 ;
44910 PyObject * obj1 = 0 ;
44911 PyObject * obj2 = 0 ;
44912 char * kwnames[] = {
44913 (char *) "self",(char *) "pos",(char *) "size", NULL
44914 };
44915
44916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44918 if (!SWIG_IsOK(res1)) {
44919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44920 }
44921 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44922 {
44923 arg2 = &temp2;
44924 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44925 }
44926 {
44927 arg3 = &temp3;
44928 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
44929 }
44930 {
44931 PyThreadState* __tstate = wxPyBeginAllowThreads();
44932 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
44933 wxPyEndAllowThreads(__tstate);
44934 if (PyErr_Occurred()) SWIG_fail;
44935 }
44936 resultobj = SWIG_Py_Void();
44937 return resultobj;
44938 fail:
44939 return NULL;
44940 }
44941
44942
44943 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44944 PyObject *resultobj = 0;
44945 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44946 wxSize result;
44947 void *argp1 = 0 ;
44948 int res1 = 0 ;
44949 PyObject *swig_obj[1] ;
44950
44951 if (!args) SWIG_fail;
44952 swig_obj[0] = args;
44953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44954 if (!SWIG_IsOK(res1)) {
44955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44956 }
44957 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44958 {
44959 PyThreadState* __tstate = wxPyBeginAllowThreads();
44960 result = (arg1)->GetMinSize();
44961 wxPyEndAllowThreads(__tstate);
44962 if (PyErr_Occurred()) SWIG_fail;
44963 }
44964 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44965 return resultobj;
44966 fail:
44967 return NULL;
44968 }
44969
44970
44971 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44972 PyObject *resultobj = 0;
44973 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44974 wxSize result;
44975 void *argp1 = 0 ;
44976 int res1 = 0 ;
44977 PyObject *swig_obj[1] ;
44978
44979 if (!args) SWIG_fail;
44980 swig_obj[0] = args;
44981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44982 if (!SWIG_IsOK(res1)) {
44983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
44984 }
44985 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44986 {
44987 PyThreadState* __tstate = wxPyBeginAllowThreads();
44988 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
44989 wxPyEndAllowThreads(__tstate);
44990 if (PyErr_Occurred()) SWIG_fail;
44991 }
44992 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44993 return resultobj;
44994 fail:
44995 return NULL;
44996 }
44997
44998
44999 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45000 PyObject *resultobj = 0;
45001 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45002 int arg2 ;
45003 int arg3 ;
45004 void *argp1 = 0 ;
45005 int res1 = 0 ;
45006 int val2 ;
45007 int ecode2 = 0 ;
45008 int val3 ;
45009 int ecode3 = 0 ;
45010 PyObject * obj0 = 0 ;
45011 PyObject * obj1 = 0 ;
45012 PyObject * obj2 = 0 ;
45013 char * kwnames[] = {
45014 (char *) "self",(char *) "x",(char *) "y", NULL
45015 };
45016
45017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45019 if (!SWIG_IsOK(res1)) {
45020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45021 }
45022 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45023 ecode2 = SWIG_AsVal_int(obj1, &val2);
45024 if (!SWIG_IsOK(ecode2)) {
45025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45026 }
45027 arg2 = static_cast< int >(val2);
45028 ecode3 = SWIG_AsVal_int(obj2, &val3);
45029 if (!SWIG_IsOK(ecode3)) {
45030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45031 }
45032 arg3 = static_cast< int >(val3);
45033 {
45034 PyThreadState* __tstate = wxPyBeginAllowThreads();
45035 (arg1)->SetInitSize(arg2,arg3);
45036 wxPyEndAllowThreads(__tstate);
45037 if (PyErr_Occurred()) SWIG_fail;
45038 }
45039 resultobj = SWIG_Py_Void();
45040 return resultobj;
45041 fail:
45042 return NULL;
45043 }
45044
45045
45046 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45047 PyObject *resultobj = 0;
45048 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45049 int arg2 ;
45050 int arg3 ;
45051 void *argp1 = 0 ;
45052 int res1 = 0 ;
45053 int val2 ;
45054 int ecode2 = 0 ;
45055 int val3 ;
45056 int ecode3 = 0 ;
45057 PyObject * obj0 = 0 ;
45058 PyObject * obj1 = 0 ;
45059 PyObject * obj2 = 0 ;
45060 char * kwnames[] = {
45061 (char *) "self",(char *) "width",(char *) "height", NULL
45062 };
45063
45064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45066 if (!SWIG_IsOK(res1)) {
45067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45068 }
45069 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45070 ecode2 = SWIG_AsVal_int(obj1, &val2);
45071 if (!SWIG_IsOK(ecode2)) {
45072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45073 }
45074 arg2 = static_cast< int >(val2);
45075 ecode3 = SWIG_AsVal_int(obj2, &val3);
45076 if (!SWIG_IsOK(ecode3)) {
45077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45078 }
45079 arg3 = static_cast< int >(val3);
45080 {
45081 PyThreadState* __tstate = wxPyBeginAllowThreads();
45082 (arg1)->SetRatio(arg2,arg3);
45083 wxPyEndAllowThreads(__tstate);
45084 if (PyErr_Occurred()) SWIG_fail;
45085 }
45086 resultobj = SWIG_Py_Void();
45087 return resultobj;
45088 fail:
45089 return NULL;
45090 }
45091
45092
45093 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45094 PyObject *resultobj = 0;
45095 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45096 wxSize *arg2 = 0 ;
45097 void *argp1 = 0 ;
45098 int res1 = 0 ;
45099 wxSize temp2 ;
45100 PyObject * obj0 = 0 ;
45101 PyObject * obj1 = 0 ;
45102 char * kwnames[] = {
45103 (char *) "self",(char *) "size", NULL
45104 };
45105
45106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45108 if (!SWIG_IsOK(res1)) {
45109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45110 }
45111 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45112 {
45113 arg2 = &temp2;
45114 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45115 }
45116 {
45117 PyThreadState* __tstate = wxPyBeginAllowThreads();
45118 (arg1)->SetRatio((wxSize const &)*arg2);
45119 wxPyEndAllowThreads(__tstate);
45120 if (PyErr_Occurred()) SWIG_fail;
45121 }
45122 resultobj = SWIG_Py_Void();
45123 return resultobj;
45124 fail:
45125 return NULL;
45126 }
45127
45128
45129 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45130 PyObject *resultobj = 0;
45131 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45132 float arg2 ;
45133 void *argp1 = 0 ;
45134 int res1 = 0 ;
45135 float val2 ;
45136 int ecode2 = 0 ;
45137 PyObject * obj0 = 0 ;
45138 PyObject * obj1 = 0 ;
45139 char * kwnames[] = {
45140 (char *) "self",(char *) "ratio", NULL
45141 };
45142
45143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45145 if (!SWIG_IsOK(res1)) {
45146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45147 }
45148 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45149 ecode2 = SWIG_AsVal_float(obj1, &val2);
45150 if (!SWIG_IsOK(ecode2)) {
45151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45152 }
45153 arg2 = static_cast< float >(val2);
45154 {
45155 PyThreadState* __tstate = wxPyBeginAllowThreads();
45156 (arg1)->SetRatio(arg2);
45157 wxPyEndAllowThreads(__tstate);
45158 if (PyErr_Occurred()) SWIG_fail;
45159 }
45160 resultobj = SWIG_Py_Void();
45161 return resultobj;
45162 fail:
45163 return NULL;
45164 }
45165
45166
45167 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45168 PyObject *resultobj = 0;
45169 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45170 float result;
45171 void *argp1 = 0 ;
45172 int res1 = 0 ;
45173 PyObject *swig_obj[1] ;
45174
45175 if (!args) SWIG_fail;
45176 swig_obj[0] = args;
45177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45178 if (!SWIG_IsOK(res1)) {
45179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45180 }
45181 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45182 {
45183 PyThreadState* __tstate = wxPyBeginAllowThreads();
45184 result = (float)(arg1)->GetRatio();
45185 wxPyEndAllowThreads(__tstate);
45186 if (PyErr_Occurred()) SWIG_fail;
45187 }
45188 resultobj = SWIG_From_float(static_cast< float >(result));
45189 return resultobj;
45190 fail:
45191 return NULL;
45192 }
45193
45194
45195 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45196 PyObject *resultobj = 0;
45197 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45198 wxRect result;
45199 void *argp1 = 0 ;
45200 int res1 = 0 ;
45201 PyObject *swig_obj[1] ;
45202
45203 if (!args) SWIG_fail;
45204 swig_obj[0] = args;
45205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45206 if (!SWIG_IsOK(res1)) {
45207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45208 }
45209 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45210 {
45211 PyThreadState* __tstate = wxPyBeginAllowThreads();
45212 result = (arg1)->GetRect();
45213 wxPyEndAllowThreads(__tstate);
45214 if (PyErr_Occurred()) SWIG_fail;
45215 }
45216 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45217 return resultobj;
45218 fail:
45219 return NULL;
45220 }
45221
45222
45223 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45224 PyObject *resultobj = 0;
45225 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45226 bool result;
45227 void *argp1 = 0 ;
45228 int res1 = 0 ;
45229 PyObject *swig_obj[1] ;
45230
45231 if (!args) SWIG_fail;
45232 swig_obj[0] = args;
45233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45234 if (!SWIG_IsOK(res1)) {
45235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45236 }
45237 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45238 {
45239 PyThreadState* __tstate = wxPyBeginAllowThreads();
45240 result = (bool)(arg1)->IsWindow();
45241 wxPyEndAllowThreads(__tstate);
45242 if (PyErr_Occurred()) SWIG_fail;
45243 }
45244 {
45245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45246 }
45247 return resultobj;
45248 fail:
45249 return NULL;
45250 }
45251
45252
45253 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45254 PyObject *resultobj = 0;
45255 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45256 bool result;
45257 void *argp1 = 0 ;
45258 int res1 = 0 ;
45259 PyObject *swig_obj[1] ;
45260
45261 if (!args) SWIG_fail;
45262 swig_obj[0] = args;
45263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45264 if (!SWIG_IsOK(res1)) {
45265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45266 }
45267 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45268 {
45269 PyThreadState* __tstate = wxPyBeginAllowThreads();
45270 result = (bool)(arg1)->IsSizer();
45271 wxPyEndAllowThreads(__tstate);
45272 if (PyErr_Occurred()) SWIG_fail;
45273 }
45274 {
45275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45276 }
45277 return resultobj;
45278 fail:
45279 return NULL;
45280 }
45281
45282
45283 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45284 PyObject *resultobj = 0;
45285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45286 bool result;
45287 void *argp1 = 0 ;
45288 int res1 = 0 ;
45289 PyObject *swig_obj[1] ;
45290
45291 if (!args) SWIG_fail;
45292 swig_obj[0] = args;
45293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45294 if (!SWIG_IsOK(res1)) {
45295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45296 }
45297 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45298 {
45299 PyThreadState* __tstate = wxPyBeginAllowThreads();
45300 result = (bool)(arg1)->IsSpacer();
45301 wxPyEndAllowThreads(__tstate);
45302 if (PyErr_Occurred()) SWIG_fail;
45303 }
45304 {
45305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45306 }
45307 return resultobj;
45308 fail:
45309 return NULL;
45310 }
45311
45312
45313 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45314 PyObject *resultobj = 0;
45315 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45316 int arg2 ;
45317 void *argp1 = 0 ;
45318 int res1 = 0 ;
45319 int val2 ;
45320 int ecode2 = 0 ;
45321 PyObject * obj0 = 0 ;
45322 PyObject * obj1 = 0 ;
45323 char * kwnames[] = {
45324 (char *) "self",(char *) "proportion", NULL
45325 };
45326
45327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45329 if (!SWIG_IsOK(res1)) {
45330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45331 }
45332 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45333 ecode2 = SWIG_AsVal_int(obj1, &val2);
45334 if (!SWIG_IsOK(ecode2)) {
45335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45336 }
45337 arg2 = static_cast< int >(val2);
45338 {
45339 PyThreadState* __tstate = wxPyBeginAllowThreads();
45340 (arg1)->SetProportion(arg2);
45341 wxPyEndAllowThreads(__tstate);
45342 if (PyErr_Occurred()) SWIG_fail;
45343 }
45344 resultobj = SWIG_Py_Void();
45345 return resultobj;
45346 fail:
45347 return NULL;
45348 }
45349
45350
45351 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45352 PyObject *resultobj = 0;
45353 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45354 int result;
45355 void *argp1 = 0 ;
45356 int res1 = 0 ;
45357 PyObject *swig_obj[1] ;
45358
45359 if (!args) SWIG_fail;
45360 swig_obj[0] = args;
45361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45362 if (!SWIG_IsOK(res1)) {
45363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45364 }
45365 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45366 {
45367 PyThreadState* __tstate = wxPyBeginAllowThreads();
45368 result = (int)(arg1)->GetProportion();
45369 wxPyEndAllowThreads(__tstate);
45370 if (PyErr_Occurred()) SWIG_fail;
45371 }
45372 resultobj = SWIG_From_int(static_cast< int >(result));
45373 return resultobj;
45374 fail:
45375 return NULL;
45376 }
45377
45378
45379 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45380 PyObject *resultobj = 0;
45381 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45382 int arg2 ;
45383 void *argp1 = 0 ;
45384 int res1 = 0 ;
45385 int val2 ;
45386 int ecode2 = 0 ;
45387 PyObject * obj0 = 0 ;
45388 PyObject * obj1 = 0 ;
45389 char * kwnames[] = {
45390 (char *) "self",(char *) "flag", NULL
45391 };
45392
45393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45395 if (!SWIG_IsOK(res1)) {
45396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45397 }
45398 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45399 ecode2 = SWIG_AsVal_int(obj1, &val2);
45400 if (!SWIG_IsOK(ecode2)) {
45401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45402 }
45403 arg2 = static_cast< int >(val2);
45404 {
45405 PyThreadState* __tstate = wxPyBeginAllowThreads();
45406 (arg1)->SetFlag(arg2);
45407 wxPyEndAllowThreads(__tstate);
45408 if (PyErr_Occurred()) SWIG_fail;
45409 }
45410 resultobj = SWIG_Py_Void();
45411 return resultobj;
45412 fail:
45413 return NULL;
45414 }
45415
45416
45417 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45418 PyObject *resultobj = 0;
45419 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45420 int result;
45421 void *argp1 = 0 ;
45422 int res1 = 0 ;
45423 PyObject *swig_obj[1] ;
45424
45425 if (!args) SWIG_fail;
45426 swig_obj[0] = args;
45427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45428 if (!SWIG_IsOK(res1)) {
45429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45430 }
45431 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45432 {
45433 PyThreadState* __tstate = wxPyBeginAllowThreads();
45434 result = (int)(arg1)->GetFlag();
45435 wxPyEndAllowThreads(__tstate);
45436 if (PyErr_Occurred()) SWIG_fail;
45437 }
45438 resultobj = SWIG_From_int(static_cast< int >(result));
45439 return resultobj;
45440 fail:
45441 return NULL;
45442 }
45443
45444
45445 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45446 PyObject *resultobj = 0;
45447 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45448 int arg2 ;
45449 void *argp1 = 0 ;
45450 int res1 = 0 ;
45451 int val2 ;
45452 int ecode2 = 0 ;
45453 PyObject * obj0 = 0 ;
45454 PyObject * obj1 = 0 ;
45455 char * kwnames[] = {
45456 (char *) "self",(char *) "border", NULL
45457 };
45458
45459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45461 if (!SWIG_IsOK(res1)) {
45462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45463 }
45464 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45465 ecode2 = SWIG_AsVal_int(obj1, &val2);
45466 if (!SWIG_IsOK(ecode2)) {
45467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45468 }
45469 arg2 = static_cast< int >(val2);
45470 {
45471 PyThreadState* __tstate = wxPyBeginAllowThreads();
45472 (arg1)->SetBorder(arg2);
45473 wxPyEndAllowThreads(__tstate);
45474 if (PyErr_Occurred()) SWIG_fail;
45475 }
45476 resultobj = SWIG_Py_Void();
45477 return resultobj;
45478 fail:
45479 return NULL;
45480 }
45481
45482
45483 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45484 PyObject *resultobj = 0;
45485 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45486 int result;
45487 void *argp1 = 0 ;
45488 int res1 = 0 ;
45489 PyObject *swig_obj[1] ;
45490
45491 if (!args) SWIG_fail;
45492 swig_obj[0] = args;
45493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45494 if (!SWIG_IsOK(res1)) {
45495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45496 }
45497 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45498 {
45499 PyThreadState* __tstate = wxPyBeginAllowThreads();
45500 result = (int)(arg1)->GetBorder();
45501 wxPyEndAllowThreads(__tstate);
45502 if (PyErr_Occurred()) SWIG_fail;
45503 }
45504 resultobj = SWIG_From_int(static_cast< int >(result));
45505 return resultobj;
45506 fail:
45507 return NULL;
45508 }
45509
45510
45511 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45512 PyObject *resultobj = 0;
45513 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45514 wxWindow *result = 0 ;
45515 void *argp1 = 0 ;
45516 int res1 = 0 ;
45517 PyObject *swig_obj[1] ;
45518
45519 if (!args) SWIG_fail;
45520 swig_obj[0] = args;
45521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45522 if (!SWIG_IsOK(res1)) {
45523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45524 }
45525 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45526 {
45527 PyThreadState* __tstate = wxPyBeginAllowThreads();
45528 result = (wxWindow *)(arg1)->GetWindow();
45529 wxPyEndAllowThreads(__tstate);
45530 if (PyErr_Occurred()) SWIG_fail;
45531 }
45532 {
45533 resultobj = wxPyMake_wxObject(result, 0);
45534 }
45535 return resultobj;
45536 fail:
45537 return NULL;
45538 }
45539
45540
45541 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45542 PyObject *resultobj = 0;
45543 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45544 wxWindow *arg2 = (wxWindow *) 0 ;
45545 void *argp1 = 0 ;
45546 int res1 = 0 ;
45547 void *argp2 = 0 ;
45548 int res2 = 0 ;
45549 PyObject * obj0 = 0 ;
45550 PyObject * obj1 = 0 ;
45551 char * kwnames[] = {
45552 (char *) "self",(char *) "window", NULL
45553 };
45554
45555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45557 if (!SWIG_IsOK(res1)) {
45558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45559 }
45560 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45561 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45562 if (!SWIG_IsOK(res2)) {
45563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45564 }
45565 arg2 = reinterpret_cast< wxWindow * >(argp2);
45566 {
45567 PyThreadState* __tstate = wxPyBeginAllowThreads();
45568 (arg1)->SetWindow(arg2);
45569 wxPyEndAllowThreads(__tstate);
45570 if (PyErr_Occurred()) SWIG_fail;
45571 }
45572 resultobj = SWIG_Py_Void();
45573 return resultobj;
45574 fail:
45575 return NULL;
45576 }
45577
45578
45579 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45580 PyObject *resultobj = 0;
45581 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45582 wxSizer *result = 0 ;
45583 void *argp1 = 0 ;
45584 int res1 = 0 ;
45585 PyObject *swig_obj[1] ;
45586
45587 if (!args) SWIG_fail;
45588 swig_obj[0] = args;
45589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45590 if (!SWIG_IsOK(res1)) {
45591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45592 }
45593 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45594 {
45595 PyThreadState* __tstate = wxPyBeginAllowThreads();
45596 result = (wxSizer *)(arg1)->GetSizer();
45597 wxPyEndAllowThreads(__tstate);
45598 if (PyErr_Occurred()) SWIG_fail;
45599 }
45600 {
45601 resultobj = wxPyMake_wxObject(result, (bool)0);
45602 }
45603 return resultobj;
45604 fail:
45605 return NULL;
45606 }
45607
45608
45609 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45610 PyObject *resultobj = 0;
45611 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45612 wxSizer *arg2 = (wxSizer *) 0 ;
45613 void *argp1 = 0 ;
45614 int res1 = 0 ;
45615 int res2 = 0 ;
45616 PyObject * obj0 = 0 ;
45617 PyObject * obj1 = 0 ;
45618 char * kwnames[] = {
45619 (char *) "self",(char *) "sizer", NULL
45620 };
45621
45622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45624 if (!SWIG_IsOK(res1)) {
45625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45626 }
45627 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45628 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45629 if (!SWIG_IsOK(res2)) {
45630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45631 }
45632 {
45633 PyThreadState* __tstate = wxPyBeginAllowThreads();
45634 (arg1)->SetSizer(arg2);
45635 wxPyEndAllowThreads(__tstate);
45636 if (PyErr_Occurred()) SWIG_fail;
45637 }
45638 resultobj = SWIG_Py_Void();
45639 return resultobj;
45640 fail:
45641 return NULL;
45642 }
45643
45644
45645 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45646 PyObject *resultobj = 0;
45647 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45648 wxSize *result = 0 ;
45649 void *argp1 = 0 ;
45650 int res1 = 0 ;
45651 PyObject *swig_obj[1] ;
45652
45653 if (!args) SWIG_fail;
45654 swig_obj[0] = args;
45655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45656 if (!SWIG_IsOK(res1)) {
45657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45658 }
45659 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45660 {
45661 PyThreadState* __tstate = wxPyBeginAllowThreads();
45662 {
45663 wxSize const &_result_ref = (arg1)->GetSpacer();
45664 result = (wxSize *) &_result_ref;
45665 }
45666 wxPyEndAllowThreads(__tstate);
45667 if (PyErr_Occurred()) SWIG_fail;
45668 }
45669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45670 return resultobj;
45671 fail:
45672 return NULL;
45673 }
45674
45675
45676 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45677 PyObject *resultobj = 0;
45678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45679 wxSize *arg2 = 0 ;
45680 void *argp1 = 0 ;
45681 int res1 = 0 ;
45682 wxSize temp2 ;
45683 PyObject * obj0 = 0 ;
45684 PyObject * obj1 = 0 ;
45685 char * kwnames[] = {
45686 (char *) "self",(char *) "size", NULL
45687 };
45688
45689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45691 if (!SWIG_IsOK(res1)) {
45692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45693 }
45694 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45695 {
45696 arg2 = &temp2;
45697 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45698 }
45699 {
45700 PyThreadState* __tstate = wxPyBeginAllowThreads();
45701 (arg1)->SetSpacer((wxSize const &)*arg2);
45702 wxPyEndAllowThreads(__tstate);
45703 if (PyErr_Occurred()) SWIG_fail;
45704 }
45705 resultobj = SWIG_Py_Void();
45706 return resultobj;
45707 fail:
45708 return NULL;
45709 }
45710
45711
45712 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45713 PyObject *resultobj = 0;
45714 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45715 bool arg2 ;
45716 void *argp1 = 0 ;
45717 int res1 = 0 ;
45718 bool val2 ;
45719 int ecode2 = 0 ;
45720 PyObject * obj0 = 0 ;
45721 PyObject * obj1 = 0 ;
45722 char * kwnames[] = {
45723 (char *) "self",(char *) "show", NULL
45724 };
45725
45726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45728 if (!SWIG_IsOK(res1)) {
45729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45730 }
45731 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45732 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45733 if (!SWIG_IsOK(ecode2)) {
45734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45735 }
45736 arg2 = static_cast< bool >(val2);
45737 {
45738 PyThreadState* __tstate = wxPyBeginAllowThreads();
45739 (arg1)->Show(arg2);
45740 wxPyEndAllowThreads(__tstate);
45741 if (PyErr_Occurred()) SWIG_fail;
45742 }
45743 resultobj = SWIG_Py_Void();
45744 return resultobj;
45745 fail:
45746 return NULL;
45747 }
45748
45749
45750 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45751 PyObject *resultobj = 0;
45752 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45753 bool result;
45754 void *argp1 = 0 ;
45755 int res1 = 0 ;
45756 PyObject *swig_obj[1] ;
45757
45758 if (!args) SWIG_fail;
45759 swig_obj[0] = args;
45760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45761 if (!SWIG_IsOK(res1)) {
45762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45763 }
45764 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45765 {
45766 PyThreadState* __tstate = wxPyBeginAllowThreads();
45767 result = (bool)(arg1)->IsShown();
45768 wxPyEndAllowThreads(__tstate);
45769 if (PyErr_Occurred()) SWIG_fail;
45770 }
45771 {
45772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45773 }
45774 return resultobj;
45775 fail:
45776 return NULL;
45777 }
45778
45779
45780 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45781 PyObject *resultobj = 0;
45782 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45783 wxPoint result;
45784 void *argp1 = 0 ;
45785 int res1 = 0 ;
45786 PyObject *swig_obj[1] ;
45787
45788 if (!args) SWIG_fail;
45789 swig_obj[0] = args;
45790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45791 if (!SWIG_IsOK(res1)) {
45792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45793 }
45794 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45795 {
45796 PyThreadState* __tstate = wxPyBeginAllowThreads();
45797 result = (arg1)->GetPosition();
45798 wxPyEndAllowThreads(__tstate);
45799 if (PyErr_Occurred()) SWIG_fail;
45800 }
45801 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45802 return resultobj;
45803 fail:
45804 return NULL;
45805 }
45806
45807
45808 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45809 PyObject *resultobj = 0;
45810 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45811 PyObject *result = 0 ;
45812 void *argp1 = 0 ;
45813 int res1 = 0 ;
45814 PyObject *swig_obj[1] ;
45815
45816 if (!args) SWIG_fail;
45817 swig_obj[0] = args;
45818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45819 if (!SWIG_IsOK(res1)) {
45820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45821 }
45822 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45823 {
45824 PyThreadState* __tstate = wxPyBeginAllowThreads();
45825 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45826 wxPyEndAllowThreads(__tstate);
45827 if (PyErr_Occurred()) SWIG_fail;
45828 }
45829 resultobj = result;
45830 return resultobj;
45831 fail:
45832 return NULL;
45833 }
45834
45835
45836 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45837 PyObject *resultobj = 0;
45838 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45839 PyObject *arg2 = (PyObject *) 0 ;
45840 void *argp1 = 0 ;
45841 int res1 = 0 ;
45842 PyObject * obj0 = 0 ;
45843 PyObject * obj1 = 0 ;
45844 char * kwnames[] = {
45845 (char *) "self",(char *) "userData", NULL
45846 };
45847
45848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45850 if (!SWIG_IsOK(res1)) {
45851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45852 }
45853 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45854 arg2 = obj1;
45855 {
45856 PyThreadState* __tstate = wxPyBeginAllowThreads();
45857 wxSizerItem_SetUserData(arg1,arg2);
45858 wxPyEndAllowThreads(__tstate);
45859 if (PyErr_Occurred()) SWIG_fail;
45860 }
45861 resultobj = SWIG_Py_Void();
45862 return resultobj;
45863 fail:
45864 return NULL;
45865 }
45866
45867
45868 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45869 PyObject *obj;
45870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45871 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45872 return SWIG_Py_Void();
45873 }
45874
45875 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45876 return SWIG_Python_InitShadowInstance(args);
45877 }
45878
45879 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45880 PyObject *resultobj = 0;
45881 wxSizer *arg1 = (wxSizer *) 0 ;
45882 void *argp1 = 0 ;
45883 int res1 = 0 ;
45884 PyObject *swig_obj[1] ;
45885
45886 if (!args) SWIG_fail;
45887 swig_obj[0] = args;
45888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45889 if (!SWIG_IsOK(res1)) {
45890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45891 }
45892 arg1 = reinterpret_cast< wxSizer * >(argp1);
45893 {
45894 PyThreadState* __tstate = wxPyBeginAllowThreads();
45895 delete arg1;
45896
45897 wxPyEndAllowThreads(__tstate);
45898 if (PyErr_Occurred()) SWIG_fail;
45899 }
45900 resultobj = SWIG_Py_Void();
45901 return resultobj;
45902 fail:
45903 return NULL;
45904 }
45905
45906
45907 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45908 PyObject *resultobj = 0;
45909 wxSizer *arg1 = (wxSizer *) 0 ;
45910 PyObject *arg2 = (PyObject *) 0 ;
45911 void *argp1 = 0 ;
45912 int res1 = 0 ;
45913 PyObject * obj0 = 0 ;
45914 PyObject * obj1 = 0 ;
45915 char * kwnames[] = {
45916 (char *) "self",(char *) "_self", NULL
45917 };
45918
45919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
45920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45921 if (!SWIG_IsOK(res1)) {
45922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
45923 }
45924 arg1 = reinterpret_cast< wxSizer * >(argp1);
45925 arg2 = obj1;
45926 {
45927 PyThreadState* __tstate = wxPyBeginAllowThreads();
45928 wxSizer__setOORInfo(arg1,arg2);
45929 wxPyEndAllowThreads(__tstate);
45930 if (PyErr_Occurred()) SWIG_fail;
45931 }
45932 resultobj = SWIG_Py_Void();
45933 return resultobj;
45934 fail:
45935 return NULL;
45936 }
45937
45938
45939 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45940 PyObject *resultobj = 0;
45941 wxSizer *arg1 = (wxSizer *) 0 ;
45942 PyObject *arg2 = (PyObject *) 0 ;
45943 int arg3 = (int) 0 ;
45944 int arg4 = (int) 0 ;
45945 int arg5 = (int) 0 ;
45946 PyObject *arg6 = (PyObject *) NULL ;
45947 wxSizerItem *result = 0 ;
45948 void *argp1 = 0 ;
45949 int res1 = 0 ;
45950 int val3 ;
45951 int ecode3 = 0 ;
45952 int val4 ;
45953 int ecode4 = 0 ;
45954 int val5 ;
45955 int ecode5 = 0 ;
45956 PyObject * obj0 = 0 ;
45957 PyObject * obj1 = 0 ;
45958 PyObject * obj2 = 0 ;
45959 PyObject * obj3 = 0 ;
45960 PyObject * obj4 = 0 ;
45961 PyObject * obj5 = 0 ;
45962 char * kwnames[] = {
45963 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45964 };
45965
45966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45968 if (!SWIG_IsOK(res1)) {
45969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
45970 }
45971 arg1 = reinterpret_cast< wxSizer * >(argp1);
45972 arg2 = obj1;
45973 if (obj2) {
45974 ecode3 = SWIG_AsVal_int(obj2, &val3);
45975 if (!SWIG_IsOK(ecode3)) {
45976 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
45977 }
45978 arg3 = static_cast< int >(val3);
45979 }
45980 if (obj3) {
45981 ecode4 = SWIG_AsVal_int(obj3, &val4);
45982 if (!SWIG_IsOK(ecode4)) {
45983 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
45984 }
45985 arg4 = static_cast< int >(val4);
45986 }
45987 if (obj4) {
45988 ecode5 = SWIG_AsVal_int(obj4, &val5);
45989 if (!SWIG_IsOK(ecode5)) {
45990 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
45991 }
45992 arg5 = static_cast< int >(val5);
45993 }
45994 if (obj5) {
45995 arg6 = obj5;
45996 }
45997 {
45998 PyThreadState* __tstate = wxPyBeginAllowThreads();
45999 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46000 wxPyEndAllowThreads(__tstate);
46001 if (PyErr_Occurred()) SWIG_fail;
46002 }
46003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46004 return resultobj;
46005 fail:
46006 return NULL;
46007 }
46008
46009
46010 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46011 PyObject *resultobj = 0;
46012 wxSizer *arg1 = (wxSizer *) 0 ;
46013 int arg2 ;
46014 PyObject *arg3 = (PyObject *) 0 ;
46015 int arg4 = (int) 0 ;
46016 int arg5 = (int) 0 ;
46017 int arg6 = (int) 0 ;
46018 PyObject *arg7 = (PyObject *) NULL ;
46019 wxSizerItem *result = 0 ;
46020 void *argp1 = 0 ;
46021 int res1 = 0 ;
46022 int val2 ;
46023 int ecode2 = 0 ;
46024 int val4 ;
46025 int ecode4 = 0 ;
46026 int val5 ;
46027 int ecode5 = 0 ;
46028 int val6 ;
46029 int ecode6 = 0 ;
46030 PyObject * obj0 = 0 ;
46031 PyObject * obj1 = 0 ;
46032 PyObject * obj2 = 0 ;
46033 PyObject * obj3 = 0 ;
46034 PyObject * obj4 = 0 ;
46035 PyObject * obj5 = 0 ;
46036 PyObject * obj6 = 0 ;
46037 char * kwnames[] = {
46038 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46039 };
46040
46041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46043 if (!SWIG_IsOK(res1)) {
46044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46045 }
46046 arg1 = reinterpret_cast< wxSizer * >(argp1);
46047 ecode2 = SWIG_AsVal_int(obj1, &val2);
46048 if (!SWIG_IsOK(ecode2)) {
46049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46050 }
46051 arg2 = static_cast< int >(val2);
46052 arg3 = obj2;
46053 if (obj3) {
46054 ecode4 = SWIG_AsVal_int(obj3, &val4);
46055 if (!SWIG_IsOK(ecode4)) {
46056 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46057 }
46058 arg4 = static_cast< int >(val4);
46059 }
46060 if (obj4) {
46061 ecode5 = SWIG_AsVal_int(obj4, &val5);
46062 if (!SWIG_IsOK(ecode5)) {
46063 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46064 }
46065 arg5 = static_cast< int >(val5);
46066 }
46067 if (obj5) {
46068 ecode6 = SWIG_AsVal_int(obj5, &val6);
46069 if (!SWIG_IsOK(ecode6)) {
46070 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46071 }
46072 arg6 = static_cast< int >(val6);
46073 }
46074 if (obj6) {
46075 arg7 = obj6;
46076 }
46077 {
46078 PyThreadState* __tstate = wxPyBeginAllowThreads();
46079 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46080 wxPyEndAllowThreads(__tstate);
46081 if (PyErr_Occurred()) SWIG_fail;
46082 }
46083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46084 return resultobj;
46085 fail:
46086 return NULL;
46087 }
46088
46089
46090 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46091 PyObject *resultobj = 0;
46092 wxSizer *arg1 = (wxSizer *) 0 ;
46093 PyObject *arg2 = (PyObject *) 0 ;
46094 int arg3 = (int) 0 ;
46095 int arg4 = (int) 0 ;
46096 int arg5 = (int) 0 ;
46097 PyObject *arg6 = (PyObject *) NULL ;
46098 wxSizerItem *result = 0 ;
46099 void *argp1 = 0 ;
46100 int res1 = 0 ;
46101 int val3 ;
46102 int ecode3 = 0 ;
46103 int val4 ;
46104 int ecode4 = 0 ;
46105 int val5 ;
46106 int ecode5 = 0 ;
46107 PyObject * obj0 = 0 ;
46108 PyObject * obj1 = 0 ;
46109 PyObject * obj2 = 0 ;
46110 PyObject * obj3 = 0 ;
46111 PyObject * obj4 = 0 ;
46112 PyObject * obj5 = 0 ;
46113 char * kwnames[] = {
46114 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46115 };
46116
46117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46119 if (!SWIG_IsOK(res1)) {
46120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46121 }
46122 arg1 = reinterpret_cast< wxSizer * >(argp1);
46123 arg2 = obj1;
46124 if (obj2) {
46125 ecode3 = SWIG_AsVal_int(obj2, &val3);
46126 if (!SWIG_IsOK(ecode3)) {
46127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46128 }
46129 arg3 = static_cast< int >(val3);
46130 }
46131 if (obj3) {
46132 ecode4 = SWIG_AsVal_int(obj3, &val4);
46133 if (!SWIG_IsOK(ecode4)) {
46134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46135 }
46136 arg4 = static_cast< int >(val4);
46137 }
46138 if (obj4) {
46139 ecode5 = SWIG_AsVal_int(obj4, &val5);
46140 if (!SWIG_IsOK(ecode5)) {
46141 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46142 }
46143 arg5 = static_cast< int >(val5);
46144 }
46145 if (obj5) {
46146 arg6 = obj5;
46147 }
46148 {
46149 PyThreadState* __tstate = wxPyBeginAllowThreads();
46150 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46151 wxPyEndAllowThreads(__tstate);
46152 if (PyErr_Occurred()) SWIG_fail;
46153 }
46154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46155 return resultobj;
46156 fail:
46157 return NULL;
46158 }
46159
46160
46161 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46162 PyObject *resultobj = 0;
46163 wxSizer *arg1 = (wxSizer *) 0 ;
46164 PyObject *arg2 = (PyObject *) 0 ;
46165 bool result;
46166 void *argp1 = 0 ;
46167 int res1 = 0 ;
46168 PyObject * obj0 = 0 ;
46169 PyObject * obj1 = 0 ;
46170 char * kwnames[] = {
46171 (char *) "self",(char *) "item", NULL
46172 };
46173
46174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46176 if (!SWIG_IsOK(res1)) {
46177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46178 }
46179 arg1 = reinterpret_cast< wxSizer * >(argp1);
46180 arg2 = obj1;
46181 {
46182 PyThreadState* __tstate = wxPyBeginAllowThreads();
46183 result = (bool)wxSizer_Remove(arg1,arg2);
46184 wxPyEndAllowThreads(__tstate);
46185 if (PyErr_Occurred()) SWIG_fail;
46186 }
46187 {
46188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46189 }
46190 return resultobj;
46191 fail:
46192 return NULL;
46193 }
46194
46195
46196 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46197 PyObject *resultobj = 0;
46198 wxSizer *arg1 = (wxSizer *) 0 ;
46199 PyObject *arg2 = (PyObject *) 0 ;
46200 bool result;
46201 void *argp1 = 0 ;
46202 int res1 = 0 ;
46203 PyObject * obj0 = 0 ;
46204 PyObject * obj1 = 0 ;
46205 char * kwnames[] = {
46206 (char *) "self",(char *) "item", NULL
46207 };
46208
46209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46211 if (!SWIG_IsOK(res1)) {
46212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46213 }
46214 arg1 = reinterpret_cast< wxSizer * >(argp1);
46215 arg2 = obj1;
46216 {
46217 PyThreadState* __tstate = wxPyBeginAllowThreads();
46218 result = (bool)wxSizer_Detach(arg1,arg2);
46219 wxPyEndAllowThreads(__tstate);
46220 if (PyErr_Occurred()) SWIG_fail;
46221 }
46222 {
46223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46224 }
46225 return resultobj;
46226 fail:
46227 return NULL;
46228 }
46229
46230
46231 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46232 PyObject *resultobj = 0;
46233 wxSizer *arg1 = (wxSizer *) 0 ;
46234 PyObject *arg2 = (PyObject *) 0 ;
46235 wxSizerItem *result = 0 ;
46236 void *argp1 = 0 ;
46237 int res1 = 0 ;
46238 PyObject * obj0 = 0 ;
46239 PyObject * obj1 = 0 ;
46240 char * kwnames[] = {
46241 (char *) "self",(char *) "item", NULL
46242 };
46243
46244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46246 if (!SWIG_IsOK(res1)) {
46247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46248 }
46249 arg1 = reinterpret_cast< wxSizer * >(argp1);
46250 arg2 = obj1;
46251 {
46252 PyThreadState* __tstate = wxPyBeginAllowThreads();
46253 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46254 wxPyEndAllowThreads(__tstate);
46255 if (PyErr_Occurred()) SWIG_fail;
46256 }
46257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46258 return resultobj;
46259 fail:
46260 return NULL;
46261 }
46262
46263
46264 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46265 PyObject *resultobj = 0;
46266 wxSizer *arg1 = (wxSizer *) 0 ;
46267 PyObject *arg2 = (PyObject *) 0 ;
46268 wxSize *arg3 = 0 ;
46269 void *argp1 = 0 ;
46270 int res1 = 0 ;
46271 wxSize temp3 ;
46272 PyObject * obj0 = 0 ;
46273 PyObject * obj1 = 0 ;
46274 PyObject * obj2 = 0 ;
46275 char * kwnames[] = {
46276 (char *) "self",(char *) "item",(char *) "size", NULL
46277 };
46278
46279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46281 if (!SWIG_IsOK(res1)) {
46282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46283 }
46284 arg1 = reinterpret_cast< wxSizer * >(argp1);
46285 arg2 = obj1;
46286 {
46287 arg3 = &temp3;
46288 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46289 }
46290 {
46291 PyThreadState* __tstate = wxPyBeginAllowThreads();
46292 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46293 wxPyEndAllowThreads(__tstate);
46294 if (PyErr_Occurred()) SWIG_fail;
46295 }
46296 resultobj = SWIG_Py_Void();
46297 return resultobj;
46298 fail:
46299 return NULL;
46300 }
46301
46302
46303 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46304 PyObject *resultobj = 0;
46305 wxSizer *arg1 = (wxSizer *) 0 ;
46306 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46307 wxSizerItem *result = 0 ;
46308 void *argp1 = 0 ;
46309 int res1 = 0 ;
46310 int res2 = 0 ;
46311 PyObject * obj0 = 0 ;
46312 PyObject * obj1 = 0 ;
46313 char * kwnames[] = {
46314 (char *) "self",(char *) "item", NULL
46315 };
46316
46317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46319 if (!SWIG_IsOK(res1)) {
46320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46321 }
46322 arg1 = reinterpret_cast< wxSizer * >(argp1);
46323 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46324 if (!SWIG_IsOK(res2)) {
46325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46326 }
46327 {
46328 PyThreadState* __tstate = wxPyBeginAllowThreads();
46329 result = (wxSizerItem *)(arg1)->Add(arg2);
46330 wxPyEndAllowThreads(__tstate);
46331 if (PyErr_Occurred()) SWIG_fail;
46332 }
46333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46334 return resultobj;
46335 fail:
46336 return NULL;
46337 }
46338
46339
46340 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46341 PyObject *resultobj = 0;
46342 wxSizer *arg1 = (wxSizer *) 0 ;
46343 size_t arg2 ;
46344 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46345 wxSizerItem *result = 0 ;
46346 void *argp1 = 0 ;
46347 int res1 = 0 ;
46348 size_t val2 ;
46349 int ecode2 = 0 ;
46350 int res3 = 0 ;
46351 PyObject * obj0 = 0 ;
46352 PyObject * obj1 = 0 ;
46353 PyObject * obj2 = 0 ;
46354 char * kwnames[] = {
46355 (char *) "self",(char *) "index",(char *) "item", NULL
46356 };
46357
46358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46360 if (!SWIG_IsOK(res1)) {
46361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46362 }
46363 arg1 = reinterpret_cast< wxSizer * >(argp1);
46364 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46365 if (!SWIG_IsOK(ecode2)) {
46366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46367 }
46368 arg2 = static_cast< size_t >(val2);
46369 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46370 if (!SWIG_IsOK(res3)) {
46371 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46372 }
46373 {
46374 PyThreadState* __tstate = wxPyBeginAllowThreads();
46375 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46376 wxPyEndAllowThreads(__tstate);
46377 if (PyErr_Occurred()) SWIG_fail;
46378 }
46379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46380 return resultobj;
46381 fail:
46382 return NULL;
46383 }
46384
46385
46386 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46387 PyObject *resultobj = 0;
46388 wxSizer *arg1 = (wxSizer *) 0 ;
46389 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46390 wxSizerItem *result = 0 ;
46391 void *argp1 = 0 ;
46392 int res1 = 0 ;
46393 int res2 = 0 ;
46394 PyObject * obj0 = 0 ;
46395 PyObject * obj1 = 0 ;
46396 char * kwnames[] = {
46397 (char *) "self",(char *) "item", NULL
46398 };
46399
46400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46402 if (!SWIG_IsOK(res1)) {
46403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46404 }
46405 arg1 = reinterpret_cast< wxSizer * >(argp1);
46406 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46407 if (!SWIG_IsOK(res2)) {
46408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46409 }
46410 {
46411 PyThreadState* __tstate = wxPyBeginAllowThreads();
46412 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46413 wxPyEndAllowThreads(__tstate);
46414 if (PyErr_Occurred()) SWIG_fail;
46415 }
46416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46417 return resultobj;
46418 fail:
46419 return NULL;
46420 }
46421
46422
46423 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46424 PyObject *resultobj = 0;
46425 wxSizer *arg1 = (wxSizer *) 0 ;
46426 int arg2 ;
46427 int arg3 ;
46428 int arg4 ;
46429 int arg5 ;
46430 void *argp1 = 0 ;
46431 int res1 = 0 ;
46432 int val2 ;
46433 int ecode2 = 0 ;
46434 int val3 ;
46435 int ecode3 = 0 ;
46436 int val4 ;
46437 int ecode4 = 0 ;
46438 int val5 ;
46439 int ecode5 = 0 ;
46440 PyObject * obj0 = 0 ;
46441 PyObject * obj1 = 0 ;
46442 PyObject * obj2 = 0 ;
46443 PyObject * obj3 = 0 ;
46444 PyObject * obj4 = 0 ;
46445 char * kwnames[] = {
46446 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46447 };
46448
46449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46451 if (!SWIG_IsOK(res1)) {
46452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46453 }
46454 arg1 = reinterpret_cast< wxSizer * >(argp1);
46455 ecode2 = SWIG_AsVal_int(obj1, &val2);
46456 if (!SWIG_IsOK(ecode2)) {
46457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46458 }
46459 arg2 = static_cast< int >(val2);
46460 ecode3 = SWIG_AsVal_int(obj2, &val3);
46461 if (!SWIG_IsOK(ecode3)) {
46462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46463 }
46464 arg3 = static_cast< int >(val3);
46465 ecode4 = SWIG_AsVal_int(obj3, &val4);
46466 if (!SWIG_IsOK(ecode4)) {
46467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46468 }
46469 arg4 = static_cast< int >(val4);
46470 ecode5 = SWIG_AsVal_int(obj4, &val5);
46471 if (!SWIG_IsOK(ecode5)) {
46472 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46473 }
46474 arg5 = static_cast< int >(val5);
46475 {
46476 PyThreadState* __tstate = wxPyBeginAllowThreads();
46477 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46478 wxPyEndAllowThreads(__tstate);
46479 if (PyErr_Occurred()) SWIG_fail;
46480 }
46481 resultobj = SWIG_Py_Void();
46482 return resultobj;
46483 fail:
46484 return NULL;
46485 }
46486
46487
46488 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46489 PyObject *resultobj = 0;
46490 wxSizer *arg1 = (wxSizer *) 0 ;
46491 wxSize *arg2 = 0 ;
46492 void *argp1 = 0 ;
46493 int res1 = 0 ;
46494 wxSize temp2 ;
46495 PyObject * obj0 = 0 ;
46496 PyObject * obj1 = 0 ;
46497 char * kwnames[] = {
46498 (char *) "self",(char *) "size", NULL
46499 };
46500
46501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46503 if (!SWIG_IsOK(res1)) {
46504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46505 }
46506 arg1 = reinterpret_cast< wxSizer * >(argp1);
46507 {
46508 arg2 = &temp2;
46509 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46510 }
46511 {
46512 PyThreadState* __tstate = wxPyBeginAllowThreads();
46513 (arg1)->SetMinSize((wxSize const &)*arg2);
46514 wxPyEndAllowThreads(__tstate);
46515 if (PyErr_Occurred()) SWIG_fail;
46516 }
46517 resultobj = SWIG_Py_Void();
46518 return resultobj;
46519 fail:
46520 return NULL;
46521 }
46522
46523
46524 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46525 PyObject *resultobj = 0;
46526 wxSizer *arg1 = (wxSizer *) 0 ;
46527 wxSize result;
46528 void *argp1 = 0 ;
46529 int res1 = 0 ;
46530 PyObject *swig_obj[1] ;
46531
46532 if (!args) SWIG_fail;
46533 swig_obj[0] = args;
46534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46535 if (!SWIG_IsOK(res1)) {
46536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46537 }
46538 arg1 = reinterpret_cast< wxSizer * >(argp1);
46539 {
46540 PyThreadState* __tstate = wxPyBeginAllowThreads();
46541 result = (arg1)->GetSize();
46542 wxPyEndAllowThreads(__tstate);
46543 if (PyErr_Occurred()) SWIG_fail;
46544 }
46545 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46546 return resultobj;
46547 fail:
46548 return NULL;
46549 }
46550
46551
46552 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46553 PyObject *resultobj = 0;
46554 wxSizer *arg1 = (wxSizer *) 0 ;
46555 wxPoint result;
46556 void *argp1 = 0 ;
46557 int res1 = 0 ;
46558 PyObject *swig_obj[1] ;
46559
46560 if (!args) SWIG_fail;
46561 swig_obj[0] = args;
46562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46563 if (!SWIG_IsOK(res1)) {
46564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46565 }
46566 arg1 = reinterpret_cast< wxSizer * >(argp1);
46567 {
46568 PyThreadState* __tstate = wxPyBeginAllowThreads();
46569 result = (arg1)->GetPosition();
46570 wxPyEndAllowThreads(__tstate);
46571 if (PyErr_Occurred()) SWIG_fail;
46572 }
46573 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46574 return resultobj;
46575 fail:
46576 return NULL;
46577 }
46578
46579
46580 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46581 PyObject *resultobj = 0;
46582 wxSizer *arg1 = (wxSizer *) 0 ;
46583 wxSize result;
46584 void *argp1 = 0 ;
46585 int res1 = 0 ;
46586 PyObject *swig_obj[1] ;
46587
46588 if (!args) SWIG_fail;
46589 swig_obj[0] = args;
46590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46591 if (!SWIG_IsOK(res1)) {
46592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46593 }
46594 arg1 = reinterpret_cast< wxSizer * >(argp1);
46595 {
46596 PyThreadState* __tstate = wxPyBeginAllowThreads();
46597 result = (arg1)->GetMinSize();
46598 wxPyEndAllowThreads(__tstate);
46599 if (PyErr_Occurred()) SWIG_fail;
46600 }
46601 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46602 return resultobj;
46603 fail:
46604 return NULL;
46605 }
46606
46607
46608 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46609 PyObject *resultobj = 0;
46610 wxSizer *arg1 = (wxSizer *) 0 ;
46611 void *argp1 = 0 ;
46612 int res1 = 0 ;
46613 PyObject *swig_obj[1] ;
46614
46615 if (!args) SWIG_fail;
46616 swig_obj[0] = args;
46617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46618 if (!SWIG_IsOK(res1)) {
46619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46620 }
46621 arg1 = reinterpret_cast< wxSizer * >(argp1);
46622 {
46623 PyThreadState* __tstate = wxPyBeginAllowThreads();
46624 (arg1)->RecalcSizes();
46625 wxPyEndAllowThreads(__tstate);
46626 if (PyErr_Occurred()) SWIG_fail;
46627 }
46628 resultobj = SWIG_Py_Void();
46629 return resultobj;
46630 fail:
46631 return NULL;
46632 }
46633
46634
46635 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46636 PyObject *resultobj = 0;
46637 wxSizer *arg1 = (wxSizer *) 0 ;
46638 wxSize result;
46639 void *argp1 = 0 ;
46640 int res1 = 0 ;
46641 PyObject *swig_obj[1] ;
46642
46643 if (!args) SWIG_fail;
46644 swig_obj[0] = args;
46645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46646 if (!SWIG_IsOK(res1)) {
46647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46648 }
46649 arg1 = reinterpret_cast< wxSizer * >(argp1);
46650 {
46651 PyThreadState* __tstate = wxPyBeginAllowThreads();
46652 result = (arg1)->CalcMin();
46653 wxPyEndAllowThreads(__tstate);
46654 if (PyErr_Occurred()) SWIG_fail;
46655 }
46656 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46657 return resultobj;
46658 fail:
46659 return NULL;
46660 }
46661
46662
46663 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46664 PyObject *resultobj = 0;
46665 wxSizer *arg1 = (wxSizer *) 0 ;
46666 void *argp1 = 0 ;
46667 int res1 = 0 ;
46668 PyObject *swig_obj[1] ;
46669
46670 if (!args) SWIG_fail;
46671 swig_obj[0] = args;
46672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46673 if (!SWIG_IsOK(res1)) {
46674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46675 }
46676 arg1 = reinterpret_cast< wxSizer * >(argp1);
46677 {
46678 PyThreadState* __tstate = wxPyBeginAllowThreads();
46679 (arg1)->Layout();
46680 wxPyEndAllowThreads(__tstate);
46681 if (PyErr_Occurred()) SWIG_fail;
46682 }
46683 resultobj = SWIG_Py_Void();
46684 return resultobj;
46685 fail:
46686 return NULL;
46687 }
46688
46689
46690 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46691 PyObject *resultobj = 0;
46692 wxSizer *arg1 = (wxSizer *) 0 ;
46693 wxWindow *arg2 = (wxWindow *) 0 ;
46694 wxSize result;
46695 void *argp1 = 0 ;
46696 int res1 = 0 ;
46697 void *argp2 = 0 ;
46698 int res2 = 0 ;
46699 PyObject * obj0 = 0 ;
46700 PyObject * obj1 = 0 ;
46701 char * kwnames[] = {
46702 (char *) "self",(char *) "window", NULL
46703 };
46704
46705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46707 if (!SWIG_IsOK(res1)) {
46708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46709 }
46710 arg1 = reinterpret_cast< wxSizer * >(argp1);
46711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46712 if (!SWIG_IsOK(res2)) {
46713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46714 }
46715 arg2 = reinterpret_cast< wxWindow * >(argp2);
46716 {
46717 PyThreadState* __tstate = wxPyBeginAllowThreads();
46718 result = (arg1)->Fit(arg2);
46719 wxPyEndAllowThreads(__tstate);
46720 if (PyErr_Occurred()) SWIG_fail;
46721 }
46722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46723 return resultobj;
46724 fail:
46725 return NULL;
46726 }
46727
46728
46729 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46730 PyObject *resultobj = 0;
46731 wxSizer *arg1 = (wxSizer *) 0 ;
46732 wxWindow *arg2 = (wxWindow *) 0 ;
46733 void *argp1 = 0 ;
46734 int res1 = 0 ;
46735 void *argp2 = 0 ;
46736 int res2 = 0 ;
46737 PyObject * obj0 = 0 ;
46738 PyObject * obj1 = 0 ;
46739 char * kwnames[] = {
46740 (char *) "self",(char *) "window", NULL
46741 };
46742
46743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46745 if (!SWIG_IsOK(res1)) {
46746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46747 }
46748 arg1 = reinterpret_cast< wxSizer * >(argp1);
46749 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46750 if (!SWIG_IsOK(res2)) {
46751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46752 }
46753 arg2 = reinterpret_cast< wxWindow * >(argp2);
46754 {
46755 PyThreadState* __tstate = wxPyBeginAllowThreads();
46756 (arg1)->FitInside(arg2);
46757 wxPyEndAllowThreads(__tstate);
46758 if (PyErr_Occurred()) SWIG_fail;
46759 }
46760 resultobj = SWIG_Py_Void();
46761 return resultobj;
46762 fail:
46763 return NULL;
46764 }
46765
46766
46767 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46768 PyObject *resultobj = 0;
46769 wxSizer *arg1 = (wxSizer *) 0 ;
46770 wxWindow *arg2 = (wxWindow *) 0 ;
46771 void *argp1 = 0 ;
46772 int res1 = 0 ;
46773 void *argp2 = 0 ;
46774 int res2 = 0 ;
46775 PyObject * obj0 = 0 ;
46776 PyObject * obj1 = 0 ;
46777 char * kwnames[] = {
46778 (char *) "self",(char *) "window", NULL
46779 };
46780
46781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46783 if (!SWIG_IsOK(res1)) {
46784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46785 }
46786 arg1 = reinterpret_cast< wxSizer * >(argp1);
46787 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46788 if (!SWIG_IsOK(res2)) {
46789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46790 }
46791 arg2 = reinterpret_cast< wxWindow * >(argp2);
46792 {
46793 PyThreadState* __tstate = wxPyBeginAllowThreads();
46794 (arg1)->SetSizeHints(arg2);
46795 wxPyEndAllowThreads(__tstate);
46796 if (PyErr_Occurred()) SWIG_fail;
46797 }
46798 resultobj = SWIG_Py_Void();
46799 return resultobj;
46800 fail:
46801 return NULL;
46802 }
46803
46804
46805 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46806 PyObject *resultobj = 0;
46807 wxSizer *arg1 = (wxSizer *) 0 ;
46808 wxWindow *arg2 = (wxWindow *) 0 ;
46809 void *argp1 = 0 ;
46810 int res1 = 0 ;
46811 void *argp2 = 0 ;
46812 int res2 = 0 ;
46813 PyObject * obj0 = 0 ;
46814 PyObject * obj1 = 0 ;
46815 char * kwnames[] = {
46816 (char *) "self",(char *) "window", NULL
46817 };
46818
46819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46821 if (!SWIG_IsOK(res1)) {
46822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46823 }
46824 arg1 = reinterpret_cast< wxSizer * >(argp1);
46825 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46826 if (!SWIG_IsOK(res2)) {
46827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46828 }
46829 arg2 = reinterpret_cast< wxWindow * >(argp2);
46830 {
46831 PyThreadState* __tstate = wxPyBeginAllowThreads();
46832 (arg1)->SetVirtualSizeHints(arg2);
46833 wxPyEndAllowThreads(__tstate);
46834 if (PyErr_Occurred()) SWIG_fail;
46835 }
46836 resultobj = SWIG_Py_Void();
46837 return resultobj;
46838 fail:
46839 return NULL;
46840 }
46841
46842
46843 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46844 PyObject *resultobj = 0;
46845 wxSizer *arg1 = (wxSizer *) 0 ;
46846 bool arg2 = (bool) false ;
46847 void *argp1 = 0 ;
46848 int res1 = 0 ;
46849 bool val2 ;
46850 int ecode2 = 0 ;
46851 PyObject * obj0 = 0 ;
46852 PyObject * obj1 = 0 ;
46853 char * kwnames[] = {
46854 (char *) "self",(char *) "deleteWindows", NULL
46855 };
46856
46857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46859 if (!SWIG_IsOK(res1)) {
46860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46861 }
46862 arg1 = reinterpret_cast< wxSizer * >(argp1);
46863 if (obj1) {
46864 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46865 if (!SWIG_IsOK(ecode2)) {
46866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46867 }
46868 arg2 = static_cast< bool >(val2);
46869 }
46870 {
46871 PyThreadState* __tstate = wxPyBeginAllowThreads();
46872 (arg1)->Clear(arg2);
46873 wxPyEndAllowThreads(__tstate);
46874 if (PyErr_Occurred()) SWIG_fail;
46875 }
46876 resultobj = SWIG_Py_Void();
46877 return resultobj;
46878 fail:
46879 return NULL;
46880 }
46881
46882
46883 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46884 PyObject *resultobj = 0;
46885 wxSizer *arg1 = (wxSizer *) 0 ;
46886 void *argp1 = 0 ;
46887 int res1 = 0 ;
46888 PyObject *swig_obj[1] ;
46889
46890 if (!args) SWIG_fail;
46891 swig_obj[0] = args;
46892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46893 if (!SWIG_IsOK(res1)) {
46894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
46895 }
46896 arg1 = reinterpret_cast< wxSizer * >(argp1);
46897 {
46898 PyThreadState* __tstate = wxPyBeginAllowThreads();
46899 (arg1)->DeleteWindows();
46900 wxPyEndAllowThreads(__tstate);
46901 if (PyErr_Occurred()) SWIG_fail;
46902 }
46903 resultobj = SWIG_Py_Void();
46904 return resultobj;
46905 fail:
46906 return NULL;
46907 }
46908
46909
46910 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46911 PyObject *resultobj = 0;
46912 wxSizer *arg1 = (wxSizer *) 0 ;
46913 PyObject *result = 0 ;
46914 void *argp1 = 0 ;
46915 int res1 = 0 ;
46916 PyObject *swig_obj[1] ;
46917
46918 if (!args) SWIG_fail;
46919 swig_obj[0] = args;
46920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46921 if (!SWIG_IsOK(res1)) {
46922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
46923 }
46924 arg1 = reinterpret_cast< wxSizer * >(argp1);
46925 {
46926 PyThreadState* __tstate = wxPyBeginAllowThreads();
46927 result = (PyObject *)wxSizer_GetChildren(arg1);
46928 wxPyEndAllowThreads(__tstate);
46929 if (PyErr_Occurred()) SWIG_fail;
46930 }
46931 resultobj = result;
46932 return resultobj;
46933 fail:
46934 return NULL;
46935 }
46936
46937
46938 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46939 PyObject *resultobj = 0;
46940 wxSizer *arg1 = (wxSizer *) 0 ;
46941 PyObject *arg2 = (PyObject *) 0 ;
46942 bool arg3 = (bool) true ;
46943 bool arg4 = (bool) false ;
46944 bool result;
46945 void *argp1 = 0 ;
46946 int res1 = 0 ;
46947 bool val3 ;
46948 int ecode3 = 0 ;
46949 bool val4 ;
46950 int ecode4 = 0 ;
46951 PyObject * obj0 = 0 ;
46952 PyObject * obj1 = 0 ;
46953 PyObject * obj2 = 0 ;
46954 PyObject * obj3 = 0 ;
46955 char * kwnames[] = {
46956 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
46957 };
46958
46959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
46960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46961 if (!SWIG_IsOK(res1)) {
46962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
46963 }
46964 arg1 = reinterpret_cast< wxSizer * >(argp1);
46965 arg2 = obj1;
46966 if (obj2) {
46967 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46968 if (!SWIG_IsOK(ecode3)) {
46969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
46970 }
46971 arg3 = static_cast< bool >(val3);
46972 }
46973 if (obj3) {
46974 ecode4 = SWIG_AsVal_bool(obj3, &val4);
46975 if (!SWIG_IsOK(ecode4)) {
46976 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
46977 }
46978 arg4 = static_cast< bool >(val4);
46979 }
46980 {
46981 PyThreadState* __tstate = wxPyBeginAllowThreads();
46982 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
46983 wxPyEndAllowThreads(__tstate);
46984 if (PyErr_Occurred()) SWIG_fail;
46985 }
46986 {
46987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46988 }
46989 return resultobj;
46990 fail:
46991 return NULL;
46992 }
46993
46994
46995 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46996 PyObject *resultobj = 0;
46997 wxSizer *arg1 = (wxSizer *) 0 ;
46998 PyObject *arg2 = (PyObject *) 0 ;
46999 bool result;
47000 void *argp1 = 0 ;
47001 int res1 = 0 ;
47002 PyObject * obj0 = 0 ;
47003 PyObject * obj1 = 0 ;
47004 char * kwnames[] = {
47005 (char *) "self",(char *) "item", NULL
47006 };
47007
47008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47010 if (!SWIG_IsOK(res1)) {
47011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47012 }
47013 arg1 = reinterpret_cast< wxSizer * >(argp1);
47014 arg2 = obj1;
47015 {
47016 PyThreadState* __tstate = wxPyBeginAllowThreads();
47017 result = (bool)wxSizer_IsShown(arg1,arg2);
47018 wxPyEndAllowThreads(__tstate);
47019 if (PyErr_Occurred()) SWIG_fail;
47020 }
47021 {
47022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47023 }
47024 return resultobj;
47025 fail:
47026 return NULL;
47027 }
47028
47029
47030 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47031 PyObject *resultobj = 0;
47032 wxSizer *arg1 = (wxSizer *) 0 ;
47033 bool arg2 ;
47034 void *argp1 = 0 ;
47035 int res1 = 0 ;
47036 bool val2 ;
47037 int ecode2 = 0 ;
47038 PyObject * obj0 = 0 ;
47039 PyObject * obj1 = 0 ;
47040 char * kwnames[] = {
47041 (char *) "self",(char *) "show", NULL
47042 };
47043
47044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47046 if (!SWIG_IsOK(res1)) {
47047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47048 }
47049 arg1 = reinterpret_cast< wxSizer * >(argp1);
47050 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47051 if (!SWIG_IsOK(ecode2)) {
47052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47053 }
47054 arg2 = static_cast< bool >(val2);
47055 {
47056 PyThreadState* __tstate = wxPyBeginAllowThreads();
47057 (arg1)->ShowItems(arg2);
47058 wxPyEndAllowThreads(__tstate);
47059 if (PyErr_Occurred()) SWIG_fail;
47060 }
47061 resultobj = SWIG_Py_Void();
47062 return resultobj;
47063 fail:
47064 return NULL;
47065 }
47066
47067
47068 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47069 PyObject *obj;
47070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47071 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47072 return SWIG_Py_Void();
47073 }
47074
47075 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47076 PyObject *resultobj = 0;
47077 wxPySizer *result = 0 ;
47078
47079 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47080 {
47081 PyThreadState* __tstate = wxPyBeginAllowThreads();
47082 result = (wxPySizer *)new wxPySizer();
47083 wxPyEndAllowThreads(__tstate);
47084 if (PyErr_Occurred()) SWIG_fail;
47085 }
47086 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47087 return resultobj;
47088 fail:
47089 return NULL;
47090 }
47091
47092
47093 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47094 PyObject *resultobj = 0;
47095 wxPySizer *arg1 = (wxPySizer *) 0 ;
47096 PyObject *arg2 = (PyObject *) 0 ;
47097 PyObject *arg3 = (PyObject *) 0 ;
47098 void *argp1 = 0 ;
47099 int res1 = 0 ;
47100 PyObject * obj0 = 0 ;
47101 PyObject * obj1 = 0 ;
47102 PyObject * obj2 = 0 ;
47103 char * kwnames[] = {
47104 (char *) "self",(char *) "self",(char *) "_class", NULL
47105 };
47106
47107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47109 if (!SWIG_IsOK(res1)) {
47110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47111 }
47112 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47113 arg2 = obj1;
47114 arg3 = obj2;
47115 {
47116 PyThreadState* __tstate = wxPyBeginAllowThreads();
47117 (arg1)->_setCallbackInfo(arg2,arg3);
47118 wxPyEndAllowThreads(__tstate);
47119 if (PyErr_Occurred()) SWIG_fail;
47120 }
47121 resultobj = SWIG_Py_Void();
47122 return resultobj;
47123 fail:
47124 return NULL;
47125 }
47126
47127
47128 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47129 PyObject *obj;
47130 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47131 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47132 return SWIG_Py_Void();
47133 }
47134
47135 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47136 return SWIG_Python_InitShadowInstance(args);
47137 }
47138
47139 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47140 PyObject *resultobj = 0;
47141 int arg1 = (int) wxHORIZONTAL ;
47142 wxBoxSizer *result = 0 ;
47143 int val1 ;
47144 int ecode1 = 0 ;
47145 PyObject * obj0 = 0 ;
47146 char * kwnames[] = {
47147 (char *) "orient", NULL
47148 };
47149
47150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47151 if (obj0) {
47152 ecode1 = SWIG_AsVal_int(obj0, &val1);
47153 if (!SWIG_IsOK(ecode1)) {
47154 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47155 }
47156 arg1 = static_cast< int >(val1);
47157 }
47158 {
47159 PyThreadState* __tstate = wxPyBeginAllowThreads();
47160 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47161 wxPyEndAllowThreads(__tstate);
47162 if (PyErr_Occurred()) SWIG_fail;
47163 }
47164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47165 return resultobj;
47166 fail:
47167 return NULL;
47168 }
47169
47170
47171 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47172 PyObject *resultobj = 0;
47173 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47174 int result;
47175 void *argp1 = 0 ;
47176 int res1 = 0 ;
47177 PyObject *swig_obj[1] ;
47178
47179 if (!args) SWIG_fail;
47180 swig_obj[0] = args;
47181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47182 if (!SWIG_IsOK(res1)) {
47183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47184 }
47185 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47186 {
47187 PyThreadState* __tstate = wxPyBeginAllowThreads();
47188 result = (int)(arg1)->GetOrientation();
47189 wxPyEndAllowThreads(__tstate);
47190 if (PyErr_Occurred()) SWIG_fail;
47191 }
47192 resultobj = SWIG_From_int(static_cast< int >(result));
47193 return resultobj;
47194 fail:
47195 return NULL;
47196 }
47197
47198
47199 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47200 PyObject *resultobj = 0;
47201 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47202 int arg2 ;
47203 void *argp1 = 0 ;
47204 int res1 = 0 ;
47205 int val2 ;
47206 int ecode2 = 0 ;
47207 PyObject * obj0 = 0 ;
47208 PyObject * obj1 = 0 ;
47209 char * kwnames[] = {
47210 (char *) "self",(char *) "orient", NULL
47211 };
47212
47213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47215 if (!SWIG_IsOK(res1)) {
47216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47217 }
47218 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47219 ecode2 = SWIG_AsVal_int(obj1, &val2);
47220 if (!SWIG_IsOK(ecode2)) {
47221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47222 }
47223 arg2 = static_cast< int >(val2);
47224 {
47225 PyThreadState* __tstate = wxPyBeginAllowThreads();
47226 (arg1)->SetOrientation(arg2);
47227 wxPyEndAllowThreads(__tstate);
47228 if (PyErr_Occurred()) SWIG_fail;
47229 }
47230 resultobj = SWIG_Py_Void();
47231 return resultobj;
47232 fail:
47233 return NULL;
47234 }
47235
47236
47237 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47238 PyObject *obj;
47239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47240 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47241 return SWIG_Py_Void();
47242 }
47243
47244 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47245 return SWIG_Python_InitShadowInstance(args);
47246 }
47247
47248 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47249 PyObject *resultobj = 0;
47250 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47251 int arg2 = (int) wxHORIZONTAL ;
47252 wxStaticBoxSizer *result = 0 ;
47253 void *argp1 = 0 ;
47254 int res1 = 0 ;
47255 int val2 ;
47256 int ecode2 = 0 ;
47257 PyObject * obj0 = 0 ;
47258 PyObject * obj1 = 0 ;
47259 char * kwnames[] = {
47260 (char *) "box",(char *) "orient", NULL
47261 };
47262
47263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47265 if (!SWIG_IsOK(res1)) {
47266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47267 }
47268 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47269 if (obj1) {
47270 ecode2 = SWIG_AsVal_int(obj1, &val2);
47271 if (!SWIG_IsOK(ecode2)) {
47272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47273 }
47274 arg2 = static_cast< int >(val2);
47275 }
47276 {
47277 PyThreadState* __tstate = wxPyBeginAllowThreads();
47278 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47279 wxPyEndAllowThreads(__tstate);
47280 if (PyErr_Occurred()) SWIG_fail;
47281 }
47282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47283 return resultobj;
47284 fail:
47285 return NULL;
47286 }
47287
47288
47289 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47290 PyObject *resultobj = 0;
47291 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47292 wxStaticBox *result = 0 ;
47293 void *argp1 = 0 ;
47294 int res1 = 0 ;
47295 PyObject *swig_obj[1] ;
47296
47297 if (!args) SWIG_fail;
47298 swig_obj[0] = args;
47299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47300 if (!SWIG_IsOK(res1)) {
47301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47302 }
47303 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47304 {
47305 PyThreadState* __tstate = wxPyBeginAllowThreads();
47306 result = (wxStaticBox *)(arg1)->GetStaticBox();
47307 wxPyEndAllowThreads(__tstate);
47308 if (PyErr_Occurred()) SWIG_fail;
47309 }
47310 {
47311 resultobj = wxPyMake_wxObject(result, (bool)0);
47312 }
47313 return resultobj;
47314 fail:
47315 return NULL;
47316 }
47317
47318
47319 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47320 PyObject *obj;
47321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47322 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47323 return SWIG_Py_Void();
47324 }
47325
47326 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47327 return SWIG_Python_InitShadowInstance(args);
47328 }
47329
47330 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47331 PyObject *resultobj = 0;
47332 int arg1 = (int) 1 ;
47333 int arg2 = (int) 0 ;
47334 int arg3 = (int) 0 ;
47335 int arg4 = (int) 0 ;
47336 wxGridSizer *result = 0 ;
47337 int val1 ;
47338 int ecode1 = 0 ;
47339 int val2 ;
47340 int ecode2 = 0 ;
47341 int val3 ;
47342 int ecode3 = 0 ;
47343 int val4 ;
47344 int ecode4 = 0 ;
47345 PyObject * obj0 = 0 ;
47346 PyObject * obj1 = 0 ;
47347 PyObject * obj2 = 0 ;
47348 PyObject * obj3 = 0 ;
47349 char * kwnames[] = {
47350 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47351 };
47352
47353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47354 if (obj0) {
47355 ecode1 = SWIG_AsVal_int(obj0, &val1);
47356 if (!SWIG_IsOK(ecode1)) {
47357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47358 }
47359 arg1 = static_cast< int >(val1);
47360 }
47361 if (obj1) {
47362 ecode2 = SWIG_AsVal_int(obj1, &val2);
47363 if (!SWIG_IsOK(ecode2)) {
47364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47365 }
47366 arg2 = static_cast< int >(val2);
47367 }
47368 if (obj2) {
47369 ecode3 = SWIG_AsVal_int(obj2, &val3);
47370 if (!SWIG_IsOK(ecode3)) {
47371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47372 }
47373 arg3 = static_cast< int >(val3);
47374 }
47375 if (obj3) {
47376 ecode4 = SWIG_AsVal_int(obj3, &val4);
47377 if (!SWIG_IsOK(ecode4)) {
47378 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47379 }
47380 arg4 = static_cast< int >(val4);
47381 }
47382 {
47383 PyThreadState* __tstate = wxPyBeginAllowThreads();
47384 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47385 wxPyEndAllowThreads(__tstate);
47386 if (PyErr_Occurred()) SWIG_fail;
47387 }
47388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47389 return resultobj;
47390 fail:
47391 return NULL;
47392 }
47393
47394
47395 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47396 PyObject *resultobj = 0;
47397 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47398 int arg2 ;
47399 void *argp1 = 0 ;
47400 int res1 = 0 ;
47401 int val2 ;
47402 int ecode2 = 0 ;
47403 PyObject * obj0 = 0 ;
47404 PyObject * obj1 = 0 ;
47405 char * kwnames[] = {
47406 (char *) "self",(char *) "cols", NULL
47407 };
47408
47409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47411 if (!SWIG_IsOK(res1)) {
47412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47413 }
47414 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47415 ecode2 = SWIG_AsVal_int(obj1, &val2);
47416 if (!SWIG_IsOK(ecode2)) {
47417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47418 }
47419 arg2 = static_cast< int >(val2);
47420 {
47421 PyThreadState* __tstate = wxPyBeginAllowThreads();
47422 (arg1)->SetCols(arg2);
47423 wxPyEndAllowThreads(__tstate);
47424 if (PyErr_Occurred()) SWIG_fail;
47425 }
47426 resultobj = SWIG_Py_Void();
47427 return resultobj;
47428 fail:
47429 return NULL;
47430 }
47431
47432
47433 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47434 PyObject *resultobj = 0;
47435 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47436 int arg2 ;
47437 void *argp1 = 0 ;
47438 int res1 = 0 ;
47439 int val2 ;
47440 int ecode2 = 0 ;
47441 PyObject * obj0 = 0 ;
47442 PyObject * obj1 = 0 ;
47443 char * kwnames[] = {
47444 (char *) "self",(char *) "rows", NULL
47445 };
47446
47447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47449 if (!SWIG_IsOK(res1)) {
47450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47451 }
47452 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47453 ecode2 = SWIG_AsVal_int(obj1, &val2);
47454 if (!SWIG_IsOK(ecode2)) {
47455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47456 }
47457 arg2 = static_cast< int >(val2);
47458 {
47459 PyThreadState* __tstate = wxPyBeginAllowThreads();
47460 (arg1)->SetRows(arg2);
47461 wxPyEndAllowThreads(__tstate);
47462 if (PyErr_Occurred()) SWIG_fail;
47463 }
47464 resultobj = SWIG_Py_Void();
47465 return resultobj;
47466 fail:
47467 return NULL;
47468 }
47469
47470
47471 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47472 PyObject *resultobj = 0;
47473 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47474 int arg2 ;
47475 void *argp1 = 0 ;
47476 int res1 = 0 ;
47477 int val2 ;
47478 int ecode2 = 0 ;
47479 PyObject * obj0 = 0 ;
47480 PyObject * obj1 = 0 ;
47481 char * kwnames[] = {
47482 (char *) "self",(char *) "gap", NULL
47483 };
47484
47485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47487 if (!SWIG_IsOK(res1)) {
47488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47489 }
47490 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47491 ecode2 = SWIG_AsVal_int(obj1, &val2);
47492 if (!SWIG_IsOK(ecode2)) {
47493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47494 }
47495 arg2 = static_cast< int >(val2);
47496 {
47497 PyThreadState* __tstate = wxPyBeginAllowThreads();
47498 (arg1)->SetVGap(arg2);
47499 wxPyEndAllowThreads(__tstate);
47500 if (PyErr_Occurred()) SWIG_fail;
47501 }
47502 resultobj = SWIG_Py_Void();
47503 return resultobj;
47504 fail:
47505 return NULL;
47506 }
47507
47508
47509 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47510 PyObject *resultobj = 0;
47511 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47512 int arg2 ;
47513 void *argp1 = 0 ;
47514 int res1 = 0 ;
47515 int val2 ;
47516 int ecode2 = 0 ;
47517 PyObject * obj0 = 0 ;
47518 PyObject * obj1 = 0 ;
47519 char * kwnames[] = {
47520 (char *) "self",(char *) "gap", NULL
47521 };
47522
47523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47525 if (!SWIG_IsOK(res1)) {
47526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47527 }
47528 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47529 ecode2 = SWIG_AsVal_int(obj1, &val2);
47530 if (!SWIG_IsOK(ecode2)) {
47531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47532 }
47533 arg2 = static_cast< int >(val2);
47534 {
47535 PyThreadState* __tstate = wxPyBeginAllowThreads();
47536 (arg1)->SetHGap(arg2);
47537 wxPyEndAllowThreads(__tstate);
47538 if (PyErr_Occurred()) SWIG_fail;
47539 }
47540 resultobj = SWIG_Py_Void();
47541 return resultobj;
47542 fail:
47543 return NULL;
47544 }
47545
47546
47547 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47548 PyObject *resultobj = 0;
47549 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47550 int result;
47551 void *argp1 = 0 ;
47552 int res1 = 0 ;
47553 PyObject *swig_obj[1] ;
47554
47555 if (!args) SWIG_fail;
47556 swig_obj[0] = args;
47557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47558 if (!SWIG_IsOK(res1)) {
47559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47560 }
47561 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47562 {
47563 PyThreadState* __tstate = wxPyBeginAllowThreads();
47564 result = (int)(arg1)->GetCols();
47565 wxPyEndAllowThreads(__tstate);
47566 if (PyErr_Occurred()) SWIG_fail;
47567 }
47568 resultobj = SWIG_From_int(static_cast< int >(result));
47569 return resultobj;
47570 fail:
47571 return NULL;
47572 }
47573
47574
47575 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47576 PyObject *resultobj = 0;
47577 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47578 int result;
47579 void *argp1 = 0 ;
47580 int res1 = 0 ;
47581 PyObject *swig_obj[1] ;
47582
47583 if (!args) SWIG_fail;
47584 swig_obj[0] = args;
47585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47586 if (!SWIG_IsOK(res1)) {
47587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47588 }
47589 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47590 {
47591 PyThreadState* __tstate = wxPyBeginAllowThreads();
47592 result = (int)(arg1)->GetRows();
47593 wxPyEndAllowThreads(__tstate);
47594 if (PyErr_Occurred()) SWIG_fail;
47595 }
47596 resultobj = SWIG_From_int(static_cast< int >(result));
47597 return resultobj;
47598 fail:
47599 return NULL;
47600 }
47601
47602
47603 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47604 PyObject *resultobj = 0;
47605 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47606 int result;
47607 void *argp1 = 0 ;
47608 int res1 = 0 ;
47609 PyObject *swig_obj[1] ;
47610
47611 if (!args) SWIG_fail;
47612 swig_obj[0] = args;
47613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47614 if (!SWIG_IsOK(res1)) {
47615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47616 }
47617 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47618 {
47619 PyThreadState* __tstate = wxPyBeginAllowThreads();
47620 result = (int)(arg1)->GetVGap();
47621 wxPyEndAllowThreads(__tstate);
47622 if (PyErr_Occurred()) SWIG_fail;
47623 }
47624 resultobj = SWIG_From_int(static_cast< int >(result));
47625 return resultobj;
47626 fail:
47627 return NULL;
47628 }
47629
47630
47631 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47632 PyObject *resultobj = 0;
47633 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47634 int result;
47635 void *argp1 = 0 ;
47636 int res1 = 0 ;
47637 PyObject *swig_obj[1] ;
47638
47639 if (!args) SWIG_fail;
47640 swig_obj[0] = args;
47641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47642 if (!SWIG_IsOK(res1)) {
47643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47644 }
47645 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47646 {
47647 PyThreadState* __tstate = wxPyBeginAllowThreads();
47648 result = (int)(arg1)->GetHGap();
47649 wxPyEndAllowThreads(__tstate);
47650 if (PyErr_Occurred()) SWIG_fail;
47651 }
47652 resultobj = SWIG_From_int(static_cast< int >(result));
47653 return resultobj;
47654 fail:
47655 return NULL;
47656 }
47657
47658
47659 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47660 PyObject *obj;
47661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47662 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47663 return SWIG_Py_Void();
47664 }
47665
47666 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47667 return SWIG_Python_InitShadowInstance(args);
47668 }
47669
47670 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47671 PyObject *resultobj = 0;
47672 int arg1 = (int) 1 ;
47673 int arg2 = (int) 0 ;
47674 int arg3 = (int) 0 ;
47675 int arg4 = (int) 0 ;
47676 wxFlexGridSizer *result = 0 ;
47677 int val1 ;
47678 int ecode1 = 0 ;
47679 int val2 ;
47680 int ecode2 = 0 ;
47681 int val3 ;
47682 int ecode3 = 0 ;
47683 int val4 ;
47684 int ecode4 = 0 ;
47685 PyObject * obj0 = 0 ;
47686 PyObject * obj1 = 0 ;
47687 PyObject * obj2 = 0 ;
47688 PyObject * obj3 = 0 ;
47689 char * kwnames[] = {
47690 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47691 };
47692
47693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47694 if (obj0) {
47695 ecode1 = SWIG_AsVal_int(obj0, &val1);
47696 if (!SWIG_IsOK(ecode1)) {
47697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47698 }
47699 arg1 = static_cast< int >(val1);
47700 }
47701 if (obj1) {
47702 ecode2 = SWIG_AsVal_int(obj1, &val2);
47703 if (!SWIG_IsOK(ecode2)) {
47704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47705 }
47706 arg2 = static_cast< int >(val2);
47707 }
47708 if (obj2) {
47709 ecode3 = SWIG_AsVal_int(obj2, &val3);
47710 if (!SWIG_IsOK(ecode3)) {
47711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47712 }
47713 arg3 = static_cast< int >(val3);
47714 }
47715 if (obj3) {
47716 ecode4 = SWIG_AsVal_int(obj3, &val4);
47717 if (!SWIG_IsOK(ecode4)) {
47718 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47719 }
47720 arg4 = static_cast< int >(val4);
47721 }
47722 {
47723 PyThreadState* __tstate = wxPyBeginAllowThreads();
47724 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47725 wxPyEndAllowThreads(__tstate);
47726 if (PyErr_Occurred()) SWIG_fail;
47727 }
47728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47729 return resultobj;
47730 fail:
47731 return NULL;
47732 }
47733
47734
47735 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47736 PyObject *resultobj = 0;
47737 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47738 size_t arg2 ;
47739 int arg3 = (int) 0 ;
47740 void *argp1 = 0 ;
47741 int res1 = 0 ;
47742 size_t val2 ;
47743 int ecode2 = 0 ;
47744 int val3 ;
47745 int ecode3 = 0 ;
47746 PyObject * obj0 = 0 ;
47747 PyObject * obj1 = 0 ;
47748 PyObject * obj2 = 0 ;
47749 char * kwnames[] = {
47750 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47751 };
47752
47753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47755 if (!SWIG_IsOK(res1)) {
47756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47757 }
47758 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47759 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47760 if (!SWIG_IsOK(ecode2)) {
47761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47762 }
47763 arg2 = static_cast< size_t >(val2);
47764 if (obj2) {
47765 ecode3 = SWIG_AsVal_int(obj2, &val3);
47766 if (!SWIG_IsOK(ecode3)) {
47767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47768 }
47769 arg3 = static_cast< int >(val3);
47770 }
47771 {
47772 PyThreadState* __tstate = wxPyBeginAllowThreads();
47773 (arg1)->AddGrowableRow(arg2,arg3);
47774 wxPyEndAllowThreads(__tstate);
47775 if (PyErr_Occurred()) SWIG_fail;
47776 }
47777 resultobj = SWIG_Py_Void();
47778 return resultobj;
47779 fail:
47780 return NULL;
47781 }
47782
47783
47784 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47785 PyObject *resultobj = 0;
47786 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47787 size_t arg2 ;
47788 void *argp1 = 0 ;
47789 int res1 = 0 ;
47790 size_t val2 ;
47791 int ecode2 = 0 ;
47792 PyObject * obj0 = 0 ;
47793 PyObject * obj1 = 0 ;
47794 char * kwnames[] = {
47795 (char *) "self",(char *) "idx", NULL
47796 };
47797
47798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47800 if (!SWIG_IsOK(res1)) {
47801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47802 }
47803 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47804 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47805 if (!SWIG_IsOK(ecode2)) {
47806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47807 }
47808 arg2 = static_cast< size_t >(val2);
47809 {
47810 PyThreadState* __tstate = wxPyBeginAllowThreads();
47811 (arg1)->RemoveGrowableRow(arg2);
47812 wxPyEndAllowThreads(__tstate);
47813 if (PyErr_Occurred()) SWIG_fail;
47814 }
47815 resultobj = SWIG_Py_Void();
47816 return resultobj;
47817 fail:
47818 return NULL;
47819 }
47820
47821
47822 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47823 PyObject *resultobj = 0;
47824 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47825 size_t arg2 ;
47826 int arg3 = (int) 0 ;
47827 void *argp1 = 0 ;
47828 int res1 = 0 ;
47829 size_t val2 ;
47830 int ecode2 = 0 ;
47831 int val3 ;
47832 int ecode3 = 0 ;
47833 PyObject * obj0 = 0 ;
47834 PyObject * obj1 = 0 ;
47835 PyObject * obj2 = 0 ;
47836 char * kwnames[] = {
47837 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47838 };
47839
47840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47842 if (!SWIG_IsOK(res1)) {
47843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47844 }
47845 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47846 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47847 if (!SWIG_IsOK(ecode2)) {
47848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47849 }
47850 arg2 = static_cast< size_t >(val2);
47851 if (obj2) {
47852 ecode3 = SWIG_AsVal_int(obj2, &val3);
47853 if (!SWIG_IsOK(ecode3)) {
47854 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47855 }
47856 arg3 = static_cast< int >(val3);
47857 }
47858 {
47859 PyThreadState* __tstate = wxPyBeginAllowThreads();
47860 (arg1)->AddGrowableCol(arg2,arg3);
47861 wxPyEndAllowThreads(__tstate);
47862 if (PyErr_Occurred()) SWIG_fail;
47863 }
47864 resultobj = SWIG_Py_Void();
47865 return resultobj;
47866 fail:
47867 return NULL;
47868 }
47869
47870
47871 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47872 PyObject *resultobj = 0;
47873 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47874 size_t arg2 ;
47875 void *argp1 = 0 ;
47876 int res1 = 0 ;
47877 size_t val2 ;
47878 int ecode2 = 0 ;
47879 PyObject * obj0 = 0 ;
47880 PyObject * obj1 = 0 ;
47881 char * kwnames[] = {
47882 (char *) "self",(char *) "idx", NULL
47883 };
47884
47885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
47886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47887 if (!SWIG_IsOK(res1)) {
47888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47889 }
47890 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47891 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47892 if (!SWIG_IsOK(ecode2)) {
47893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47894 }
47895 arg2 = static_cast< size_t >(val2);
47896 {
47897 PyThreadState* __tstate = wxPyBeginAllowThreads();
47898 (arg1)->RemoveGrowableCol(arg2);
47899 wxPyEndAllowThreads(__tstate);
47900 if (PyErr_Occurred()) SWIG_fail;
47901 }
47902 resultobj = SWIG_Py_Void();
47903 return resultobj;
47904 fail:
47905 return NULL;
47906 }
47907
47908
47909 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47910 PyObject *resultobj = 0;
47911 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47912 int arg2 ;
47913 void *argp1 = 0 ;
47914 int res1 = 0 ;
47915 int val2 ;
47916 int ecode2 = 0 ;
47917 PyObject * obj0 = 0 ;
47918 PyObject * obj1 = 0 ;
47919 char * kwnames[] = {
47920 (char *) "self",(char *) "direction", NULL
47921 };
47922
47923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
47924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47925 if (!SWIG_IsOK(res1)) {
47926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47927 }
47928 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47929 ecode2 = SWIG_AsVal_int(obj1, &val2);
47930 if (!SWIG_IsOK(ecode2)) {
47931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
47932 }
47933 arg2 = static_cast< int >(val2);
47934 {
47935 PyThreadState* __tstate = wxPyBeginAllowThreads();
47936 (arg1)->SetFlexibleDirection(arg2);
47937 wxPyEndAllowThreads(__tstate);
47938 if (PyErr_Occurred()) SWIG_fail;
47939 }
47940 resultobj = SWIG_Py_Void();
47941 return resultobj;
47942 fail:
47943 return NULL;
47944 }
47945
47946
47947 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47948 PyObject *resultobj = 0;
47949 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47950 int result;
47951 void *argp1 = 0 ;
47952 int res1 = 0 ;
47953 PyObject *swig_obj[1] ;
47954
47955 if (!args) SWIG_fail;
47956 swig_obj[0] = args;
47957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47958 if (!SWIG_IsOK(res1)) {
47959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47960 }
47961 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47962 {
47963 PyThreadState* __tstate = wxPyBeginAllowThreads();
47964 result = (int)(arg1)->GetFlexibleDirection();
47965 wxPyEndAllowThreads(__tstate);
47966 if (PyErr_Occurred()) SWIG_fail;
47967 }
47968 resultobj = SWIG_From_int(static_cast< int >(result));
47969 return resultobj;
47970 fail:
47971 return NULL;
47972 }
47973
47974
47975 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47976 PyObject *resultobj = 0;
47977 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47978 wxFlexSizerGrowMode arg2 ;
47979 void *argp1 = 0 ;
47980 int res1 = 0 ;
47981 int val2 ;
47982 int ecode2 = 0 ;
47983 PyObject * obj0 = 0 ;
47984 PyObject * obj1 = 0 ;
47985 char * kwnames[] = {
47986 (char *) "self",(char *) "mode", NULL
47987 };
47988
47989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
47990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47991 if (!SWIG_IsOK(res1)) {
47992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47993 }
47994 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47995 ecode2 = SWIG_AsVal_int(obj1, &val2);
47996 if (!SWIG_IsOK(ecode2)) {
47997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
47998 }
47999 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48000 {
48001 PyThreadState* __tstate = wxPyBeginAllowThreads();
48002 (arg1)->SetNonFlexibleGrowMode(arg2);
48003 wxPyEndAllowThreads(__tstate);
48004 if (PyErr_Occurred()) SWIG_fail;
48005 }
48006 resultobj = SWIG_Py_Void();
48007 return resultobj;
48008 fail:
48009 return NULL;
48010 }
48011
48012
48013 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48014 PyObject *resultobj = 0;
48015 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48016 wxFlexSizerGrowMode result;
48017 void *argp1 = 0 ;
48018 int res1 = 0 ;
48019 PyObject *swig_obj[1] ;
48020
48021 if (!args) SWIG_fail;
48022 swig_obj[0] = args;
48023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48024 if (!SWIG_IsOK(res1)) {
48025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48026 }
48027 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48028 {
48029 PyThreadState* __tstate = wxPyBeginAllowThreads();
48030 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48031 wxPyEndAllowThreads(__tstate);
48032 if (PyErr_Occurred()) SWIG_fail;
48033 }
48034 resultobj = SWIG_From_int(static_cast< int >(result));
48035 return resultobj;
48036 fail:
48037 return NULL;
48038 }
48039
48040
48041 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48042 PyObject *resultobj = 0;
48043 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48044 wxArrayInt *result = 0 ;
48045 void *argp1 = 0 ;
48046 int res1 = 0 ;
48047 PyObject *swig_obj[1] ;
48048
48049 if (!args) SWIG_fail;
48050 swig_obj[0] = args;
48051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48052 if (!SWIG_IsOK(res1)) {
48053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48054 }
48055 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48056 {
48057 PyThreadState* __tstate = wxPyBeginAllowThreads();
48058 {
48059 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48060 result = (wxArrayInt *) &_result_ref;
48061 }
48062 wxPyEndAllowThreads(__tstate);
48063 if (PyErr_Occurred()) SWIG_fail;
48064 }
48065 {
48066 resultobj = PyList_New(0);
48067 size_t idx;
48068 for (idx = 0; idx < result->GetCount(); idx += 1) {
48069 PyObject* val = PyInt_FromLong( result->Item(idx) );
48070 PyList_Append(resultobj, val);
48071 Py_DECREF(val);
48072 }
48073 }
48074 return resultobj;
48075 fail:
48076 return NULL;
48077 }
48078
48079
48080 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48081 PyObject *resultobj = 0;
48082 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48083 wxArrayInt *result = 0 ;
48084 void *argp1 = 0 ;
48085 int res1 = 0 ;
48086 PyObject *swig_obj[1] ;
48087
48088 if (!args) SWIG_fail;
48089 swig_obj[0] = args;
48090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48091 if (!SWIG_IsOK(res1)) {
48092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48093 }
48094 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48095 {
48096 PyThreadState* __tstate = wxPyBeginAllowThreads();
48097 {
48098 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48099 result = (wxArrayInt *) &_result_ref;
48100 }
48101 wxPyEndAllowThreads(__tstate);
48102 if (PyErr_Occurred()) SWIG_fail;
48103 }
48104 {
48105 resultobj = PyList_New(0);
48106 size_t idx;
48107 for (idx = 0; idx < result->GetCount(); idx += 1) {
48108 PyObject* val = PyInt_FromLong( result->Item(idx) );
48109 PyList_Append(resultobj, val);
48110 Py_DECREF(val);
48111 }
48112 }
48113 return resultobj;
48114 fail:
48115 return NULL;
48116 }
48117
48118
48119 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48120 PyObject *obj;
48121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48122 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48123 return SWIG_Py_Void();
48124 }
48125
48126 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48127 return SWIG_Python_InitShadowInstance(args);
48128 }
48129
48130 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48131 PyObject *resultobj = 0;
48132 wxStdDialogButtonSizer *result = 0 ;
48133
48134 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48135 {
48136 PyThreadState* __tstate = wxPyBeginAllowThreads();
48137 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48138 wxPyEndAllowThreads(__tstate);
48139 if (PyErr_Occurred()) SWIG_fail;
48140 }
48141 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48142 return resultobj;
48143 fail:
48144 return NULL;
48145 }
48146
48147
48148 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48149 PyObject *resultobj = 0;
48150 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48151 wxButton *arg2 = (wxButton *) 0 ;
48152 void *argp1 = 0 ;
48153 int res1 = 0 ;
48154 void *argp2 = 0 ;
48155 int res2 = 0 ;
48156 PyObject * obj0 = 0 ;
48157 PyObject * obj1 = 0 ;
48158 char * kwnames[] = {
48159 (char *) "self",(char *) "button", NULL
48160 };
48161
48162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48164 if (!SWIG_IsOK(res1)) {
48165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48166 }
48167 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48169 if (!SWIG_IsOK(res2)) {
48170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48171 }
48172 arg2 = reinterpret_cast< wxButton * >(argp2);
48173 {
48174 PyThreadState* __tstate = wxPyBeginAllowThreads();
48175 (arg1)->AddButton(arg2);
48176 wxPyEndAllowThreads(__tstate);
48177 if (PyErr_Occurred()) SWIG_fail;
48178 }
48179 resultobj = SWIG_Py_Void();
48180 return resultobj;
48181 fail:
48182 return NULL;
48183 }
48184
48185
48186 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48187 PyObject *resultobj = 0;
48188 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48189 void *argp1 = 0 ;
48190 int res1 = 0 ;
48191 PyObject *swig_obj[1] ;
48192
48193 if (!args) SWIG_fail;
48194 swig_obj[0] = args;
48195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48196 if (!SWIG_IsOK(res1)) {
48197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48198 }
48199 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48200 {
48201 PyThreadState* __tstate = wxPyBeginAllowThreads();
48202 (arg1)->Realize();
48203 wxPyEndAllowThreads(__tstate);
48204 if (PyErr_Occurred()) SWIG_fail;
48205 }
48206 resultobj = SWIG_Py_Void();
48207 return resultobj;
48208 fail:
48209 return NULL;
48210 }
48211
48212
48213 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48214 PyObject *resultobj = 0;
48215 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48216 wxButton *arg2 = (wxButton *) 0 ;
48217 void *argp1 = 0 ;
48218 int res1 = 0 ;
48219 void *argp2 = 0 ;
48220 int res2 = 0 ;
48221 PyObject * obj0 = 0 ;
48222 PyObject * obj1 = 0 ;
48223 char * kwnames[] = {
48224 (char *) "self",(char *) "button", NULL
48225 };
48226
48227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48229 if (!SWIG_IsOK(res1)) {
48230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48231 }
48232 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48233 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48234 if (!SWIG_IsOK(res2)) {
48235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48236 }
48237 arg2 = reinterpret_cast< wxButton * >(argp2);
48238 {
48239 PyThreadState* __tstate = wxPyBeginAllowThreads();
48240 (arg1)->SetAffirmativeButton(arg2);
48241 wxPyEndAllowThreads(__tstate);
48242 if (PyErr_Occurred()) SWIG_fail;
48243 }
48244 resultobj = SWIG_Py_Void();
48245 return resultobj;
48246 fail:
48247 return NULL;
48248 }
48249
48250
48251 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48252 PyObject *resultobj = 0;
48253 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48254 wxButton *arg2 = (wxButton *) 0 ;
48255 void *argp1 = 0 ;
48256 int res1 = 0 ;
48257 void *argp2 = 0 ;
48258 int res2 = 0 ;
48259 PyObject * obj0 = 0 ;
48260 PyObject * obj1 = 0 ;
48261 char * kwnames[] = {
48262 (char *) "self",(char *) "button", NULL
48263 };
48264
48265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48267 if (!SWIG_IsOK(res1)) {
48268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48269 }
48270 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48272 if (!SWIG_IsOK(res2)) {
48273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48274 }
48275 arg2 = reinterpret_cast< wxButton * >(argp2);
48276 {
48277 PyThreadState* __tstate = wxPyBeginAllowThreads();
48278 (arg1)->SetNegativeButton(arg2);
48279 wxPyEndAllowThreads(__tstate);
48280 if (PyErr_Occurred()) SWIG_fail;
48281 }
48282 resultobj = SWIG_Py_Void();
48283 return resultobj;
48284 fail:
48285 return NULL;
48286 }
48287
48288
48289 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48290 PyObject *resultobj = 0;
48291 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48292 wxButton *arg2 = (wxButton *) 0 ;
48293 void *argp1 = 0 ;
48294 int res1 = 0 ;
48295 void *argp2 = 0 ;
48296 int res2 = 0 ;
48297 PyObject * obj0 = 0 ;
48298 PyObject * obj1 = 0 ;
48299 char * kwnames[] = {
48300 (char *) "self",(char *) "button", NULL
48301 };
48302
48303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48305 if (!SWIG_IsOK(res1)) {
48306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48307 }
48308 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48309 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48310 if (!SWIG_IsOK(res2)) {
48311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48312 }
48313 arg2 = reinterpret_cast< wxButton * >(argp2);
48314 {
48315 PyThreadState* __tstate = wxPyBeginAllowThreads();
48316 (arg1)->SetCancelButton(arg2);
48317 wxPyEndAllowThreads(__tstate);
48318 if (PyErr_Occurred()) SWIG_fail;
48319 }
48320 resultobj = SWIG_Py_Void();
48321 return resultobj;
48322 fail:
48323 return NULL;
48324 }
48325
48326
48327 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48328 PyObject *resultobj = 0;
48329 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48330 wxButton *result = 0 ;
48331 void *argp1 = 0 ;
48332 int res1 = 0 ;
48333 PyObject *swig_obj[1] ;
48334
48335 if (!args) SWIG_fail;
48336 swig_obj[0] = args;
48337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48338 if (!SWIG_IsOK(res1)) {
48339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48340 }
48341 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48342 {
48343 PyThreadState* __tstate = wxPyBeginAllowThreads();
48344 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48345 wxPyEndAllowThreads(__tstate);
48346 if (PyErr_Occurred()) SWIG_fail;
48347 }
48348 {
48349 resultobj = wxPyMake_wxObject(result, (bool)0);
48350 }
48351 return resultobj;
48352 fail:
48353 return NULL;
48354 }
48355
48356
48357 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48358 PyObject *resultobj = 0;
48359 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48360 wxButton *result = 0 ;
48361 void *argp1 = 0 ;
48362 int res1 = 0 ;
48363 PyObject *swig_obj[1] ;
48364
48365 if (!args) SWIG_fail;
48366 swig_obj[0] = args;
48367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48368 if (!SWIG_IsOK(res1)) {
48369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48370 }
48371 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48372 {
48373 PyThreadState* __tstate = wxPyBeginAllowThreads();
48374 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48375 wxPyEndAllowThreads(__tstate);
48376 if (PyErr_Occurred()) SWIG_fail;
48377 }
48378 {
48379 resultobj = wxPyMake_wxObject(result, (bool)0);
48380 }
48381 return resultobj;
48382 fail:
48383 return NULL;
48384 }
48385
48386
48387 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48388 PyObject *resultobj = 0;
48389 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48390 wxButton *result = 0 ;
48391 void *argp1 = 0 ;
48392 int res1 = 0 ;
48393 PyObject *swig_obj[1] ;
48394
48395 if (!args) SWIG_fail;
48396 swig_obj[0] = args;
48397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48398 if (!SWIG_IsOK(res1)) {
48399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48400 }
48401 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48402 {
48403 PyThreadState* __tstate = wxPyBeginAllowThreads();
48404 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48405 wxPyEndAllowThreads(__tstate);
48406 if (PyErr_Occurred()) SWIG_fail;
48407 }
48408 {
48409 resultobj = wxPyMake_wxObject(result, (bool)0);
48410 }
48411 return resultobj;
48412 fail:
48413 return NULL;
48414 }
48415
48416
48417 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48418 PyObject *resultobj = 0;
48419 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48420 wxButton *result = 0 ;
48421 void *argp1 = 0 ;
48422 int res1 = 0 ;
48423 PyObject *swig_obj[1] ;
48424
48425 if (!args) SWIG_fail;
48426 swig_obj[0] = args;
48427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48428 if (!SWIG_IsOK(res1)) {
48429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48430 }
48431 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48432 {
48433 PyThreadState* __tstate = wxPyBeginAllowThreads();
48434 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48435 wxPyEndAllowThreads(__tstate);
48436 if (PyErr_Occurred()) SWIG_fail;
48437 }
48438 {
48439 resultobj = wxPyMake_wxObject(result, (bool)0);
48440 }
48441 return resultobj;
48442 fail:
48443 return NULL;
48444 }
48445
48446
48447 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48448 PyObject *resultobj = 0;
48449 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48450 wxButton *result = 0 ;
48451 void *argp1 = 0 ;
48452 int res1 = 0 ;
48453 PyObject *swig_obj[1] ;
48454
48455 if (!args) SWIG_fail;
48456 swig_obj[0] = args;
48457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48458 if (!SWIG_IsOK(res1)) {
48459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48460 }
48461 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48462 {
48463 PyThreadState* __tstate = wxPyBeginAllowThreads();
48464 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48465 wxPyEndAllowThreads(__tstate);
48466 if (PyErr_Occurred()) SWIG_fail;
48467 }
48468 {
48469 resultobj = wxPyMake_wxObject(result, (bool)0);
48470 }
48471 return resultobj;
48472 fail:
48473 return NULL;
48474 }
48475
48476
48477 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48478 PyObject *obj;
48479 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48480 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48481 return SWIG_Py_Void();
48482 }
48483
48484 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48485 return SWIG_Python_InitShadowInstance(args);
48486 }
48487
48488 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48489 PyObject *resultobj = 0;
48490 int arg1 = (int) 0 ;
48491 int arg2 = (int) 0 ;
48492 wxGBPosition *result = 0 ;
48493 int val1 ;
48494 int ecode1 = 0 ;
48495 int val2 ;
48496 int ecode2 = 0 ;
48497 PyObject * obj0 = 0 ;
48498 PyObject * obj1 = 0 ;
48499 char * kwnames[] = {
48500 (char *) "row",(char *) "col", NULL
48501 };
48502
48503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48504 if (obj0) {
48505 ecode1 = SWIG_AsVal_int(obj0, &val1);
48506 if (!SWIG_IsOK(ecode1)) {
48507 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48508 }
48509 arg1 = static_cast< int >(val1);
48510 }
48511 if (obj1) {
48512 ecode2 = SWIG_AsVal_int(obj1, &val2);
48513 if (!SWIG_IsOK(ecode2)) {
48514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48515 }
48516 arg2 = static_cast< int >(val2);
48517 }
48518 {
48519 PyThreadState* __tstate = wxPyBeginAllowThreads();
48520 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48521 wxPyEndAllowThreads(__tstate);
48522 if (PyErr_Occurred()) SWIG_fail;
48523 }
48524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48525 return resultobj;
48526 fail:
48527 return NULL;
48528 }
48529
48530
48531 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48532 PyObject *resultobj = 0;
48533 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48534 void *argp1 = 0 ;
48535 int res1 = 0 ;
48536 PyObject *swig_obj[1] ;
48537
48538 if (!args) SWIG_fail;
48539 swig_obj[0] = args;
48540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48541 if (!SWIG_IsOK(res1)) {
48542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48543 }
48544 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48545 {
48546 PyThreadState* __tstate = wxPyBeginAllowThreads();
48547 delete arg1;
48548
48549 wxPyEndAllowThreads(__tstate);
48550 if (PyErr_Occurred()) SWIG_fail;
48551 }
48552 resultobj = SWIG_Py_Void();
48553 return resultobj;
48554 fail:
48555 return NULL;
48556 }
48557
48558
48559 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48560 PyObject *resultobj = 0;
48561 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48562 int result;
48563 void *argp1 = 0 ;
48564 int res1 = 0 ;
48565 PyObject *swig_obj[1] ;
48566
48567 if (!args) SWIG_fail;
48568 swig_obj[0] = args;
48569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48570 if (!SWIG_IsOK(res1)) {
48571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48572 }
48573 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48574 {
48575 PyThreadState* __tstate = wxPyBeginAllowThreads();
48576 result = (int)((wxGBPosition const *)arg1)->GetRow();
48577 wxPyEndAllowThreads(__tstate);
48578 if (PyErr_Occurred()) SWIG_fail;
48579 }
48580 resultobj = SWIG_From_int(static_cast< int >(result));
48581 return resultobj;
48582 fail:
48583 return NULL;
48584 }
48585
48586
48587 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48588 PyObject *resultobj = 0;
48589 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48590 int result;
48591 void *argp1 = 0 ;
48592 int res1 = 0 ;
48593 PyObject *swig_obj[1] ;
48594
48595 if (!args) SWIG_fail;
48596 swig_obj[0] = args;
48597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48598 if (!SWIG_IsOK(res1)) {
48599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48600 }
48601 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48602 {
48603 PyThreadState* __tstate = wxPyBeginAllowThreads();
48604 result = (int)((wxGBPosition const *)arg1)->GetCol();
48605 wxPyEndAllowThreads(__tstate);
48606 if (PyErr_Occurred()) SWIG_fail;
48607 }
48608 resultobj = SWIG_From_int(static_cast< int >(result));
48609 return resultobj;
48610 fail:
48611 return NULL;
48612 }
48613
48614
48615 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48616 PyObject *resultobj = 0;
48617 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48618 int arg2 ;
48619 void *argp1 = 0 ;
48620 int res1 = 0 ;
48621 int val2 ;
48622 int ecode2 = 0 ;
48623 PyObject * obj0 = 0 ;
48624 PyObject * obj1 = 0 ;
48625 char * kwnames[] = {
48626 (char *) "self",(char *) "row", NULL
48627 };
48628
48629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48631 if (!SWIG_IsOK(res1)) {
48632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48633 }
48634 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48635 ecode2 = SWIG_AsVal_int(obj1, &val2);
48636 if (!SWIG_IsOK(ecode2)) {
48637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48638 }
48639 arg2 = static_cast< int >(val2);
48640 {
48641 PyThreadState* __tstate = wxPyBeginAllowThreads();
48642 (arg1)->SetRow(arg2);
48643 wxPyEndAllowThreads(__tstate);
48644 if (PyErr_Occurred()) SWIG_fail;
48645 }
48646 resultobj = SWIG_Py_Void();
48647 return resultobj;
48648 fail:
48649 return NULL;
48650 }
48651
48652
48653 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48654 PyObject *resultobj = 0;
48655 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48656 int arg2 ;
48657 void *argp1 = 0 ;
48658 int res1 = 0 ;
48659 int val2 ;
48660 int ecode2 = 0 ;
48661 PyObject * obj0 = 0 ;
48662 PyObject * obj1 = 0 ;
48663 char * kwnames[] = {
48664 (char *) "self",(char *) "col", NULL
48665 };
48666
48667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48669 if (!SWIG_IsOK(res1)) {
48670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48671 }
48672 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48673 ecode2 = SWIG_AsVal_int(obj1, &val2);
48674 if (!SWIG_IsOK(ecode2)) {
48675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48676 }
48677 arg2 = static_cast< int >(val2);
48678 {
48679 PyThreadState* __tstate = wxPyBeginAllowThreads();
48680 (arg1)->SetCol(arg2);
48681 wxPyEndAllowThreads(__tstate);
48682 if (PyErr_Occurred()) SWIG_fail;
48683 }
48684 resultobj = SWIG_Py_Void();
48685 return resultobj;
48686 fail:
48687 return NULL;
48688 }
48689
48690
48691 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48692 PyObject *resultobj = 0;
48693 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48694 wxGBPosition *arg2 = 0 ;
48695 bool result;
48696 void *argp1 = 0 ;
48697 int res1 = 0 ;
48698 wxGBPosition temp2 ;
48699 PyObject * obj0 = 0 ;
48700 PyObject * obj1 = 0 ;
48701 char * kwnames[] = {
48702 (char *) "self",(char *) "other", NULL
48703 };
48704
48705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48707 if (!SWIG_IsOK(res1)) {
48708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48709 }
48710 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48711 {
48712 arg2 = &temp2;
48713 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48714 }
48715 {
48716 PyThreadState* __tstate = wxPyBeginAllowThreads();
48717 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
48718 wxPyEndAllowThreads(__tstate);
48719 if (PyErr_Occurred()) SWIG_fail;
48720 }
48721 {
48722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48723 }
48724 return resultobj;
48725 fail:
48726 return NULL;
48727 }
48728
48729
48730 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48731 PyObject *resultobj = 0;
48732 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48733 wxGBPosition *arg2 = 0 ;
48734 bool result;
48735 void *argp1 = 0 ;
48736 int res1 = 0 ;
48737 wxGBPosition temp2 ;
48738 PyObject * obj0 = 0 ;
48739 PyObject * obj1 = 0 ;
48740 char * kwnames[] = {
48741 (char *) "self",(char *) "other", NULL
48742 };
48743
48744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48746 if (!SWIG_IsOK(res1)) {
48747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48748 }
48749 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48750 {
48751 arg2 = &temp2;
48752 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48753 }
48754 {
48755 PyThreadState* __tstate = wxPyBeginAllowThreads();
48756 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
48757 wxPyEndAllowThreads(__tstate);
48758 if (PyErr_Occurred()) SWIG_fail;
48759 }
48760 {
48761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48762 }
48763 return resultobj;
48764 fail:
48765 return NULL;
48766 }
48767
48768
48769 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48770 PyObject *resultobj = 0;
48771 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48772 int arg2 = (int) 0 ;
48773 int arg3 = (int) 0 ;
48774 void *argp1 = 0 ;
48775 int res1 = 0 ;
48776 int val2 ;
48777 int ecode2 = 0 ;
48778 int val3 ;
48779 int ecode3 = 0 ;
48780 PyObject * obj0 = 0 ;
48781 PyObject * obj1 = 0 ;
48782 PyObject * obj2 = 0 ;
48783 char * kwnames[] = {
48784 (char *) "self",(char *) "row",(char *) "col", NULL
48785 };
48786
48787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48789 if (!SWIG_IsOK(res1)) {
48790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48791 }
48792 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48793 if (obj1) {
48794 ecode2 = SWIG_AsVal_int(obj1, &val2);
48795 if (!SWIG_IsOK(ecode2)) {
48796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48797 }
48798 arg2 = static_cast< int >(val2);
48799 }
48800 if (obj2) {
48801 ecode3 = SWIG_AsVal_int(obj2, &val3);
48802 if (!SWIG_IsOK(ecode3)) {
48803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48804 }
48805 arg3 = static_cast< int >(val3);
48806 }
48807 {
48808 PyThreadState* __tstate = wxPyBeginAllowThreads();
48809 wxGBPosition_Set(arg1,arg2,arg3);
48810 wxPyEndAllowThreads(__tstate);
48811 if (PyErr_Occurred()) SWIG_fail;
48812 }
48813 resultobj = SWIG_Py_Void();
48814 return resultobj;
48815 fail:
48816 return NULL;
48817 }
48818
48819
48820 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48821 PyObject *resultobj = 0;
48822 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48823 PyObject *result = 0 ;
48824 void *argp1 = 0 ;
48825 int res1 = 0 ;
48826 PyObject *swig_obj[1] ;
48827
48828 if (!args) SWIG_fail;
48829 swig_obj[0] = args;
48830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48831 if (!SWIG_IsOK(res1)) {
48832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48833 }
48834 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48835 {
48836 PyThreadState* __tstate = wxPyBeginAllowThreads();
48837 result = (PyObject *)wxGBPosition_Get(arg1);
48838 wxPyEndAllowThreads(__tstate);
48839 if (PyErr_Occurred()) SWIG_fail;
48840 }
48841 resultobj = result;
48842 return resultobj;
48843 fail:
48844 return NULL;
48845 }
48846
48847
48848 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48849 PyObject *obj;
48850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48851 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48852 return SWIG_Py_Void();
48853 }
48854
48855 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48856 return SWIG_Python_InitShadowInstance(args);
48857 }
48858
48859 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48860 PyObject *resultobj = 0;
48861 int arg1 = (int) 1 ;
48862 int arg2 = (int) 1 ;
48863 wxGBSpan *result = 0 ;
48864 int val1 ;
48865 int ecode1 = 0 ;
48866 int val2 ;
48867 int ecode2 = 0 ;
48868 PyObject * obj0 = 0 ;
48869 PyObject * obj1 = 0 ;
48870 char * kwnames[] = {
48871 (char *) "rowspan",(char *) "colspan", NULL
48872 };
48873
48874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48875 if (obj0) {
48876 ecode1 = SWIG_AsVal_int(obj0, &val1);
48877 if (!SWIG_IsOK(ecode1)) {
48878 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48879 }
48880 arg1 = static_cast< int >(val1);
48881 }
48882 if (obj1) {
48883 ecode2 = SWIG_AsVal_int(obj1, &val2);
48884 if (!SWIG_IsOK(ecode2)) {
48885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48886 }
48887 arg2 = static_cast< int >(val2);
48888 }
48889 {
48890 PyThreadState* __tstate = wxPyBeginAllowThreads();
48891 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48892 wxPyEndAllowThreads(__tstate);
48893 if (PyErr_Occurred()) SWIG_fail;
48894 }
48895 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
48896 return resultobj;
48897 fail:
48898 return NULL;
48899 }
48900
48901
48902 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48903 PyObject *resultobj = 0;
48904 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48905 void *argp1 = 0 ;
48906 int res1 = 0 ;
48907 PyObject *swig_obj[1] ;
48908
48909 if (!args) SWIG_fail;
48910 swig_obj[0] = args;
48911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
48912 if (!SWIG_IsOK(res1)) {
48913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48914 }
48915 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48916 {
48917 PyThreadState* __tstate = wxPyBeginAllowThreads();
48918 delete arg1;
48919
48920 wxPyEndAllowThreads(__tstate);
48921 if (PyErr_Occurred()) SWIG_fail;
48922 }
48923 resultobj = SWIG_Py_Void();
48924 return resultobj;
48925 fail:
48926 return NULL;
48927 }
48928
48929
48930 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48931 PyObject *resultobj = 0;
48932 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48933 int result;
48934 void *argp1 = 0 ;
48935 int res1 = 0 ;
48936 PyObject *swig_obj[1] ;
48937
48938 if (!args) SWIG_fail;
48939 swig_obj[0] = args;
48940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48941 if (!SWIG_IsOK(res1)) {
48942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48943 }
48944 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48945 {
48946 PyThreadState* __tstate = wxPyBeginAllowThreads();
48947 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
48948 wxPyEndAllowThreads(__tstate);
48949 if (PyErr_Occurred()) SWIG_fail;
48950 }
48951 resultobj = SWIG_From_int(static_cast< int >(result));
48952 return resultobj;
48953 fail:
48954 return NULL;
48955 }
48956
48957
48958 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48959 PyObject *resultobj = 0;
48960 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48961 int result;
48962 void *argp1 = 0 ;
48963 int res1 = 0 ;
48964 PyObject *swig_obj[1] ;
48965
48966 if (!args) SWIG_fail;
48967 swig_obj[0] = args;
48968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48969 if (!SWIG_IsOK(res1)) {
48970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48971 }
48972 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48973 {
48974 PyThreadState* __tstate = wxPyBeginAllowThreads();
48975 result = (int)((wxGBSpan const *)arg1)->GetColspan();
48976 wxPyEndAllowThreads(__tstate);
48977 if (PyErr_Occurred()) SWIG_fail;
48978 }
48979 resultobj = SWIG_From_int(static_cast< int >(result));
48980 return resultobj;
48981 fail:
48982 return NULL;
48983 }
48984
48985
48986 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48987 PyObject *resultobj = 0;
48988 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48989 int arg2 ;
48990 void *argp1 = 0 ;
48991 int res1 = 0 ;
48992 int val2 ;
48993 int ecode2 = 0 ;
48994 PyObject * obj0 = 0 ;
48995 PyObject * obj1 = 0 ;
48996 char * kwnames[] = {
48997 (char *) "self",(char *) "rowspan", NULL
48998 };
48999
49000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49002 if (!SWIG_IsOK(res1)) {
49003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49004 }
49005 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49006 ecode2 = SWIG_AsVal_int(obj1, &val2);
49007 if (!SWIG_IsOK(ecode2)) {
49008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49009 }
49010 arg2 = static_cast< int >(val2);
49011 {
49012 PyThreadState* __tstate = wxPyBeginAllowThreads();
49013 (arg1)->SetRowspan(arg2);
49014 wxPyEndAllowThreads(__tstate);
49015 if (PyErr_Occurred()) SWIG_fail;
49016 }
49017 resultobj = SWIG_Py_Void();
49018 return resultobj;
49019 fail:
49020 return NULL;
49021 }
49022
49023
49024 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49025 PyObject *resultobj = 0;
49026 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49027 int arg2 ;
49028 void *argp1 = 0 ;
49029 int res1 = 0 ;
49030 int val2 ;
49031 int ecode2 = 0 ;
49032 PyObject * obj0 = 0 ;
49033 PyObject * obj1 = 0 ;
49034 char * kwnames[] = {
49035 (char *) "self",(char *) "colspan", NULL
49036 };
49037
49038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49040 if (!SWIG_IsOK(res1)) {
49041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49042 }
49043 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49044 ecode2 = SWIG_AsVal_int(obj1, &val2);
49045 if (!SWIG_IsOK(ecode2)) {
49046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49047 }
49048 arg2 = static_cast< int >(val2);
49049 {
49050 PyThreadState* __tstate = wxPyBeginAllowThreads();
49051 (arg1)->SetColspan(arg2);
49052 wxPyEndAllowThreads(__tstate);
49053 if (PyErr_Occurred()) SWIG_fail;
49054 }
49055 resultobj = SWIG_Py_Void();
49056 return resultobj;
49057 fail:
49058 return NULL;
49059 }
49060
49061
49062 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49063 PyObject *resultobj = 0;
49064 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49065 wxGBSpan *arg2 = 0 ;
49066 bool result;
49067 void *argp1 = 0 ;
49068 int res1 = 0 ;
49069 wxGBSpan temp2 ;
49070 PyObject * obj0 = 0 ;
49071 PyObject * obj1 = 0 ;
49072 char * kwnames[] = {
49073 (char *) "self",(char *) "other", NULL
49074 };
49075
49076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49078 if (!SWIG_IsOK(res1)) {
49079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49080 }
49081 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49082 {
49083 arg2 = &temp2;
49084 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49085 }
49086 {
49087 PyThreadState* __tstate = wxPyBeginAllowThreads();
49088 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
49089 wxPyEndAllowThreads(__tstate);
49090 if (PyErr_Occurred()) SWIG_fail;
49091 }
49092 {
49093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49094 }
49095 return resultobj;
49096 fail:
49097 return NULL;
49098 }
49099
49100
49101 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49102 PyObject *resultobj = 0;
49103 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49104 wxGBSpan *arg2 = 0 ;
49105 bool result;
49106 void *argp1 = 0 ;
49107 int res1 = 0 ;
49108 wxGBSpan temp2 ;
49109 PyObject * obj0 = 0 ;
49110 PyObject * obj1 = 0 ;
49111 char * kwnames[] = {
49112 (char *) "self",(char *) "other", NULL
49113 };
49114
49115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49117 if (!SWIG_IsOK(res1)) {
49118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49119 }
49120 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49121 {
49122 arg2 = &temp2;
49123 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49124 }
49125 {
49126 PyThreadState* __tstate = wxPyBeginAllowThreads();
49127 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
49128 wxPyEndAllowThreads(__tstate);
49129 if (PyErr_Occurred()) SWIG_fail;
49130 }
49131 {
49132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49133 }
49134 return resultobj;
49135 fail:
49136 return NULL;
49137 }
49138
49139
49140 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49141 PyObject *resultobj = 0;
49142 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49143 int arg2 = (int) 1 ;
49144 int arg3 = (int) 1 ;
49145 void *argp1 = 0 ;
49146 int res1 = 0 ;
49147 int val2 ;
49148 int ecode2 = 0 ;
49149 int val3 ;
49150 int ecode3 = 0 ;
49151 PyObject * obj0 = 0 ;
49152 PyObject * obj1 = 0 ;
49153 PyObject * obj2 = 0 ;
49154 char * kwnames[] = {
49155 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49156 };
49157
49158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49160 if (!SWIG_IsOK(res1)) {
49161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49162 }
49163 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49164 if (obj1) {
49165 ecode2 = SWIG_AsVal_int(obj1, &val2);
49166 if (!SWIG_IsOK(ecode2)) {
49167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49168 }
49169 arg2 = static_cast< int >(val2);
49170 }
49171 if (obj2) {
49172 ecode3 = SWIG_AsVal_int(obj2, &val3);
49173 if (!SWIG_IsOK(ecode3)) {
49174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49175 }
49176 arg3 = static_cast< int >(val3);
49177 }
49178 {
49179 PyThreadState* __tstate = wxPyBeginAllowThreads();
49180 wxGBSpan_Set(arg1,arg2,arg3);
49181 wxPyEndAllowThreads(__tstate);
49182 if (PyErr_Occurred()) SWIG_fail;
49183 }
49184 resultobj = SWIG_Py_Void();
49185 return resultobj;
49186 fail:
49187 return NULL;
49188 }
49189
49190
49191 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49192 PyObject *resultobj = 0;
49193 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49194 PyObject *result = 0 ;
49195 void *argp1 = 0 ;
49196 int res1 = 0 ;
49197 PyObject *swig_obj[1] ;
49198
49199 if (!args) SWIG_fail;
49200 swig_obj[0] = args;
49201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49202 if (!SWIG_IsOK(res1)) {
49203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49204 }
49205 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49206 {
49207 PyThreadState* __tstate = wxPyBeginAllowThreads();
49208 result = (PyObject *)wxGBSpan_Get(arg1);
49209 wxPyEndAllowThreads(__tstate);
49210 if (PyErr_Occurred()) SWIG_fail;
49211 }
49212 resultobj = result;
49213 return resultobj;
49214 fail:
49215 return NULL;
49216 }
49217
49218
49219 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49220 PyObject *obj;
49221 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49222 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49223 return SWIG_Py_Void();
49224 }
49225
49226 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49227 return SWIG_Python_InitShadowInstance(args);
49228 }
49229
49230 SWIGINTERN int DefaultSpan_set(PyObject *) {
49231 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49232 return 1;
49233 }
49234
49235
49236 SWIGINTERN PyObject *DefaultSpan_get(void) {
49237 PyObject *pyobj = 0;
49238
49239 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49240 return pyobj;
49241 }
49242
49243
49244 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49245 PyObject *resultobj = 0;
49246 wxGBSizerItem *result = 0 ;
49247
49248 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49249 {
49250 PyThreadState* __tstate = wxPyBeginAllowThreads();
49251 result = (wxGBSizerItem *)new wxGBSizerItem();
49252 wxPyEndAllowThreads(__tstate);
49253 if (PyErr_Occurred()) SWIG_fail;
49254 }
49255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49256 return resultobj;
49257 fail:
49258 return NULL;
49259 }
49260
49261
49262 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49263 PyObject *resultobj = 0;
49264 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49265 void *argp1 = 0 ;
49266 int res1 = 0 ;
49267 PyObject *swig_obj[1] ;
49268
49269 if (!args) SWIG_fail;
49270 swig_obj[0] = args;
49271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49272 if (!SWIG_IsOK(res1)) {
49273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49274 }
49275 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49276 {
49277 PyThreadState* __tstate = wxPyBeginAllowThreads();
49278 delete arg1;
49279
49280 wxPyEndAllowThreads(__tstate);
49281 if (PyErr_Occurred()) SWIG_fail;
49282 }
49283 resultobj = SWIG_Py_Void();
49284 return resultobj;
49285 fail:
49286 return NULL;
49287 }
49288
49289
49290 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49291 PyObject *resultobj = 0;
49292 wxWindow *arg1 = (wxWindow *) 0 ;
49293 wxGBPosition *arg2 = 0 ;
49294 wxGBSpan *arg3 = 0 ;
49295 int arg4 ;
49296 int arg5 ;
49297 PyObject *arg6 = (PyObject *) NULL ;
49298 wxGBSizerItem *result = 0 ;
49299 void *argp1 = 0 ;
49300 int res1 = 0 ;
49301 wxGBPosition temp2 ;
49302 wxGBSpan temp3 ;
49303 int val4 ;
49304 int ecode4 = 0 ;
49305 int val5 ;
49306 int ecode5 = 0 ;
49307 PyObject * obj0 = 0 ;
49308 PyObject * obj1 = 0 ;
49309 PyObject * obj2 = 0 ;
49310 PyObject * obj3 = 0 ;
49311 PyObject * obj4 = 0 ;
49312 PyObject * obj5 = 0 ;
49313 char * kwnames[] = {
49314 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49315 };
49316
49317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49319 if (!SWIG_IsOK(res1)) {
49320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49321 }
49322 arg1 = reinterpret_cast< wxWindow * >(argp1);
49323 {
49324 arg2 = &temp2;
49325 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49326 }
49327 {
49328 arg3 = &temp3;
49329 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49330 }
49331 ecode4 = SWIG_AsVal_int(obj3, &val4);
49332 if (!SWIG_IsOK(ecode4)) {
49333 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49334 }
49335 arg4 = static_cast< int >(val4);
49336 ecode5 = SWIG_AsVal_int(obj4, &val5);
49337 if (!SWIG_IsOK(ecode5)) {
49338 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49339 }
49340 arg5 = static_cast< int >(val5);
49341 if (obj5) {
49342 arg6 = obj5;
49343 }
49344 {
49345 PyThreadState* __tstate = wxPyBeginAllowThreads();
49346 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49347 wxPyEndAllowThreads(__tstate);
49348 if (PyErr_Occurred()) SWIG_fail;
49349 }
49350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49351 return resultobj;
49352 fail:
49353 return NULL;
49354 }
49355
49356
49357 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49358 PyObject *resultobj = 0;
49359 wxSizer *arg1 = (wxSizer *) 0 ;
49360 wxGBPosition *arg2 = 0 ;
49361 wxGBSpan *arg3 = 0 ;
49362 int arg4 ;
49363 int arg5 ;
49364 PyObject *arg6 = (PyObject *) NULL ;
49365 wxGBSizerItem *result = 0 ;
49366 int res1 = 0 ;
49367 wxGBPosition temp2 ;
49368 wxGBSpan temp3 ;
49369 int val4 ;
49370 int ecode4 = 0 ;
49371 int val5 ;
49372 int ecode5 = 0 ;
49373 PyObject * obj0 = 0 ;
49374 PyObject * obj1 = 0 ;
49375 PyObject * obj2 = 0 ;
49376 PyObject * obj3 = 0 ;
49377 PyObject * obj4 = 0 ;
49378 PyObject * obj5 = 0 ;
49379 char * kwnames[] = {
49380 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49381 };
49382
49383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49384 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49385 if (!SWIG_IsOK(res1)) {
49386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49387 }
49388 {
49389 arg2 = &temp2;
49390 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49391 }
49392 {
49393 arg3 = &temp3;
49394 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49395 }
49396 ecode4 = SWIG_AsVal_int(obj3, &val4);
49397 if (!SWIG_IsOK(ecode4)) {
49398 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49399 }
49400 arg4 = static_cast< int >(val4);
49401 ecode5 = SWIG_AsVal_int(obj4, &val5);
49402 if (!SWIG_IsOK(ecode5)) {
49403 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49404 }
49405 arg5 = static_cast< int >(val5);
49406 if (obj5) {
49407 arg6 = obj5;
49408 }
49409 {
49410 PyThreadState* __tstate = wxPyBeginAllowThreads();
49411 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49412 wxPyEndAllowThreads(__tstate);
49413 if (PyErr_Occurred()) SWIG_fail;
49414 }
49415 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49416 return resultobj;
49417 fail:
49418 return NULL;
49419 }
49420
49421
49422 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49423 PyObject *resultobj = 0;
49424 int arg1 ;
49425 int arg2 ;
49426 wxGBPosition *arg3 = 0 ;
49427 wxGBSpan *arg4 = 0 ;
49428 int arg5 ;
49429 int arg6 ;
49430 PyObject *arg7 = (PyObject *) NULL ;
49431 wxGBSizerItem *result = 0 ;
49432 int val1 ;
49433 int ecode1 = 0 ;
49434 int val2 ;
49435 int ecode2 = 0 ;
49436 wxGBPosition temp3 ;
49437 wxGBSpan temp4 ;
49438 int val5 ;
49439 int ecode5 = 0 ;
49440 int val6 ;
49441 int ecode6 = 0 ;
49442 PyObject * obj0 = 0 ;
49443 PyObject * obj1 = 0 ;
49444 PyObject * obj2 = 0 ;
49445 PyObject * obj3 = 0 ;
49446 PyObject * obj4 = 0 ;
49447 PyObject * obj5 = 0 ;
49448 PyObject * obj6 = 0 ;
49449 char * kwnames[] = {
49450 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49451 };
49452
49453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49454 ecode1 = SWIG_AsVal_int(obj0, &val1);
49455 if (!SWIG_IsOK(ecode1)) {
49456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49457 }
49458 arg1 = static_cast< int >(val1);
49459 ecode2 = SWIG_AsVal_int(obj1, &val2);
49460 if (!SWIG_IsOK(ecode2)) {
49461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49462 }
49463 arg2 = static_cast< int >(val2);
49464 {
49465 arg3 = &temp3;
49466 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49467 }
49468 {
49469 arg4 = &temp4;
49470 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49471 }
49472 ecode5 = SWIG_AsVal_int(obj4, &val5);
49473 if (!SWIG_IsOK(ecode5)) {
49474 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49475 }
49476 arg5 = static_cast< int >(val5);
49477 ecode6 = SWIG_AsVal_int(obj5, &val6);
49478 if (!SWIG_IsOK(ecode6)) {
49479 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49480 }
49481 arg6 = static_cast< int >(val6);
49482 if (obj6) {
49483 arg7 = obj6;
49484 }
49485 {
49486 PyThreadState* __tstate = wxPyBeginAllowThreads();
49487 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49488 wxPyEndAllowThreads(__tstate);
49489 if (PyErr_Occurred()) SWIG_fail;
49490 }
49491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49492 return resultobj;
49493 fail:
49494 return NULL;
49495 }
49496
49497
49498 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49499 PyObject *resultobj = 0;
49500 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49501 wxGBPosition result;
49502 void *argp1 = 0 ;
49503 int res1 = 0 ;
49504 PyObject *swig_obj[1] ;
49505
49506 if (!args) SWIG_fail;
49507 swig_obj[0] = args;
49508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49509 if (!SWIG_IsOK(res1)) {
49510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49511 }
49512 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49513 {
49514 PyThreadState* __tstate = wxPyBeginAllowThreads();
49515 result = ((wxGBSizerItem const *)arg1)->GetPos();
49516 wxPyEndAllowThreads(__tstate);
49517 if (PyErr_Occurred()) SWIG_fail;
49518 }
49519 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49520 return resultobj;
49521 fail:
49522 return NULL;
49523 }
49524
49525
49526 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49527 PyObject *resultobj = 0;
49528 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49529 wxGBSpan result;
49530 void *argp1 = 0 ;
49531 int res1 = 0 ;
49532 PyObject *swig_obj[1] ;
49533
49534 if (!args) SWIG_fail;
49535 swig_obj[0] = args;
49536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49537 if (!SWIG_IsOK(res1)) {
49538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49539 }
49540 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49541 {
49542 PyThreadState* __tstate = wxPyBeginAllowThreads();
49543 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49544 wxPyEndAllowThreads(__tstate);
49545 if (PyErr_Occurred()) SWIG_fail;
49546 }
49547 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49548 return resultobj;
49549 fail:
49550 return NULL;
49551 }
49552
49553
49554 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49555 PyObject *resultobj = 0;
49556 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49557 wxGBPosition *arg2 = 0 ;
49558 bool result;
49559 void *argp1 = 0 ;
49560 int res1 = 0 ;
49561 wxGBPosition temp2 ;
49562 PyObject * obj0 = 0 ;
49563 PyObject * obj1 = 0 ;
49564 char * kwnames[] = {
49565 (char *) "self",(char *) "pos", NULL
49566 };
49567
49568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49570 if (!SWIG_IsOK(res1)) {
49571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49572 }
49573 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49574 {
49575 arg2 = &temp2;
49576 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49577 }
49578 {
49579 PyThreadState* __tstate = wxPyBeginAllowThreads();
49580 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49581 wxPyEndAllowThreads(__tstate);
49582 if (PyErr_Occurred()) SWIG_fail;
49583 }
49584 {
49585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49586 }
49587 return resultobj;
49588 fail:
49589 return NULL;
49590 }
49591
49592
49593 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49594 PyObject *resultobj = 0;
49595 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49596 wxGBSpan *arg2 = 0 ;
49597 bool result;
49598 void *argp1 = 0 ;
49599 int res1 = 0 ;
49600 wxGBSpan temp2 ;
49601 PyObject * obj0 = 0 ;
49602 PyObject * obj1 = 0 ;
49603 char * kwnames[] = {
49604 (char *) "self",(char *) "span", NULL
49605 };
49606
49607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49609 if (!SWIG_IsOK(res1)) {
49610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49611 }
49612 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49613 {
49614 arg2 = &temp2;
49615 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49616 }
49617 {
49618 PyThreadState* __tstate = wxPyBeginAllowThreads();
49619 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49620 wxPyEndAllowThreads(__tstate);
49621 if (PyErr_Occurred()) SWIG_fail;
49622 }
49623 {
49624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49625 }
49626 return resultobj;
49627 fail:
49628 return NULL;
49629 }
49630
49631
49632 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49633 PyObject *resultobj = 0;
49634 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49635 wxGBSizerItem *arg2 = 0 ;
49636 bool result;
49637 void *argp1 = 0 ;
49638 int res1 = 0 ;
49639 void *argp2 = 0 ;
49640 int res2 = 0 ;
49641 PyObject * obj0 = 0 ;
49642 PyObject * obj1 = 0 ;
49643 char * kwnames[] = {
49644 (char *) "self",(char *) "other", NULL
49645 };
49646
49647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49649 if (!SWIG_IsOK(res1)) {
49650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49651 }
49652 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49653 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49654 if (!SWIG_IsOK(res2)) {
49655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49656 }
49657 if (!argp2) {
49658 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49659 }
49660 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49661 {
49662 PyThreadState* __tstate = wxPyBeginAllowThreads();
49663 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49664 wxPyEndAllowThreads(__tstate);
49665 if (PyErr_Occurred()) SWIG_fail;
49666 }
49667 {
49668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49669 }
49670 return resultobj;
49671 fail:
49672 return NULL;
49673 }
49674
49675
49676 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49677 PyObject *resultobj = 0;
49678 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49679 wxGBPosition *arg2 = 0 ;
49680 wxGBSpan *arg3 = 0 ;
49681 bool result;
49682 void *argp1 = 0 ;
49683 int res1 = 0 ;
49684 wxGBPosition temp2 ;
49685 wxGBSpan temp3 ;
49686 PyObject * obj0 = 0 ;
49687 PyObject * obj1 = 0 ;
49688 PyObject * obj2 = 0 ;
49689 char * kwnames[] = {
49690 (char *) "self",(char *) "pos",(char *) "span", NULL
49691 };
49692
49693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49695 if (!SWIG_IsOK(res1)) {
49696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49697 }
49698 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49699 {
49700 arg2 = &temp2;
49701 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49702 }
49703 {
49704 arg3 = &temp3;
49705 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49706 }
49707 {
49708 PyThreadState* __tstate = wxPyBeginAllowThreads();
49709 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49710 wxPyEndAllowThreads(__tstate);
49711 if (PyErr_Occurred()) SWIG_fail;
49712 }
49713 {
49714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49715 }
49716 return resultobj;
49717 fail:
49718 return NULL;
49719 }
49720
49721
49722 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49723 PyObject *resultobj = 0;
49724 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49725 wxGBPosition result;
49726 void *argp1 = 0 ;
49727 int res1 = 0 ;
49728 PyObject *swig_obj[1] ;
49729
49730 if (!args) SWIG_fail;
49731 swig_obj[0] = args;
49732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49733 if (!SWIG_IsOK(res1)) {
49734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49735 }
49736 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49737 {
49738 PyThreadState* __tstate = wxPyBeginAllowThreads();
49739 result = wxGBSizerItem_GetEndPos(arg1);
49740 wxPyEndAllowThreads(__tstate);
49741 if (PyErr_Occurred()) SWIG_fail;
49742 }
49743 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49744 return resultobj;
49745 fail:
49746 return NULL;
49747 }
49748
49749
49750 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49751 PyObject *resultobj = 0;
49752 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49753 wxGridBagSizer *result = 0 ;
49754 void *argp1 = 0 ;
49755 int res1 = 0 ;
49756 PyObject *swig_obj[1] ;
49757
49758 if (!args) SWIG_fail;
49759 swig_obj[0] = args;
49760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49761 if (!SWIG_IsOK(res1)) {
49762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49763 }
49764 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49765 {
49766 PyThreadState* __tstate = wxPyBeginAllowThreads();
49767 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49768 wxPyEndAllowThreads(__tstate);
49769 if (PyErr_Occurred()) SWIG_fail;
49770 }
49771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49772 return resultobj;
49773 fail:
49774 return NULL;
49775 }
49776
49777
49778 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49779 PyObject *resultobj = 0;
49780 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49781 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49782 void *argp1 = 0 ;
49783 int res1 = 0 ;
49784 void *argp2 = 0 ;
49785 int res2 = 0 ;
49786 PyObject * obj0 = 0 ;
49787 PyObject * obj1 = 0 ;
49788 char * kwnames[] = {
49789 (char *) "self",(char *) "sizer", NULL
49790 };
49791
49792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49794 if (!SWIG_IsOK(res1)) {
49795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49796 }
49797 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49798 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49799 if (!SWIG_IsOK(res2)) {
49800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49801 }
49802 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49803 {
49804 PyThreadState* __tstate = wxPyBeginAllowThreads();
49805 (arg1)->SetGBSizer(arg2);
49806 wxPyEndAllowThreads(__tstate);
49807 if (PyErr_Occurred()) SWIG_fail;
49808 }
49809 resultobj = SWIG_Py_Void();
49810 return resultobj;
49811 fail:
49812 return NULL;
49813 }
49814
49815
49816 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49817 PyObject *obj;
49818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49819 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49820 return SWIG_Py_Void();
49821 }
49822
49823 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49824 return SWIG_Python_InitShadowInstance(args);
49825 }
49826
49827 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49828 PyObject *resultobj = 0;
49829 int arg1 = (int) 0 ;
49830 int arg2 = (int) 0 ;
49831 wxGridBagSizer *result = 0 ;
49832 int val1 ;
49833 int ecode1 = 0 ;
49834 int val2 ;
49835 int ecode2 = 0 ;
49836 PyObject * obj0 = 0 ;
49837 PyObject * obj1 = 0 ;
49838 char * kwnames[] = {
49839 (char *) "vgap",(char *) "hgap", NULL
49840 };
49841
49842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49843 if (obj0) {
49844 ecode1 = SWIG_AsVal_int(obj0, &val1);
49845 if (!SWIG_IsOK(ecode1)) {
49846 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49847 }
49848 arg1 = static_cast< int >(val1);
49849 }
49850 if (obj1) {
49851 ecode2 = SWIG_AsVal_int(obj1, &val2);
49852 if (!SWIG_IsOK(ecode2)) {
49853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49854 }
49855 arg2 = static_cast< int >(val2);
49856 }
49857 {
49858 PyThreadState* __tstate = wxPyBeginAllowThreads();
49859 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49860 wxPyEndAllowThreads(__tstate);
49861 if (PyErr_Occurred()) SWIG_fail;
49862 }
49863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49864 return resultobj;
49865 fail:
49866 return NULL;
49867 }
49868
49869
49870 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49871 PyObject *resultobj = 0;
49872 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49873 PyObject *arg2 = (PyObject *) 0 ;
49874 wxGBPosition *arg3 = 0 ;
49875 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49876 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49877 int arg5 = (int) 0 ;
49878 int arg6 = (int) 0 ;
49879 PyObject *arg7 = (PyObject *) NULL ;
49880 wxGBSizerItem *result = 0 ;
49881 void *argp1 = 0 ;
49882 int res1 = 0 ;
49883 wxGBPosition temp3 ;
49884 wxGBSpan temp4 ;
49885 int val5 ;
49886 int ecode5 = 0 ;
49887 int val6 ;
49888 int ecode6 = 0 ;
49889 PyObject * obj0 = 0 ;
49890 PyObject * obj1 = 0 ;
49891 PyObject * obj2 = 0 ;
49892 PyObject * obj3 = 0 ;
49893 PyObject * obj4 = 0 ;
49894 PyObject * obj5 = 0 ;
49895 PyObject * obj6 = 0 ;
49896 char * kwnames[] = {
49897 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49898 };
49899
49900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49902 if (!SWIG_IsOK(res1)) {
49903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49904 }
49905 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49906 arg2 = obj1;
49907 {
49908 arg3 = &temp3;
49909 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49910 }
49911 if (obj3) {
49912 {
49913 arg4 = &temp4;
49914 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49915 }
49916 }
49917 if (obj4) {
49918 ecode5 = SWIG_AsVal_int(obj4, &val5);
49919 if (!SWIG_IsOK(ecode5)) {
49920 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
49921 }
49922 arg5 = static_cast< int >(val5);
49923 }
49924 if (obj5) {
49925 ecode6 = SWIG_AsVal_int(obj5, &val6);
49926 if (!SWIG_IsOK(ecode6)) {
49927 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
49928 }
49929 arg6 = static_cast< int >(val6);
49930 }
49931 if (obj6) {
49932 arg7 = obj6;
49933 }
49934 {
49935 PyThreadState* __tstate = wxPyBeginAllowThreads();
49936 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49937 wxPyEndAllowThreads(__tstate);
49938 if (PyErr_Occurred()) SWIG_fail;
49939 }
49940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49941 return resultobj;
49942 fail:
49943 return NULL;
49944 }
49945
49946
49947 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49948 PyObject *resultobj = 0;
49949 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49950 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
49951 wxGBSizerItem *result = 0 ;
49952 void *argp1 = 0 ;
49953 int res1 = 0 ;
49954 int res2 = 0 ;
49955 PyObject * obj0 = 0 ;
49956 PyObject * obj1 = 0 ;
49957 char * kwnames[] = {
49958 (char *) "self",(char *) "item", NULL
49959 };
49960
49961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
49962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49963 if (!SWIG_IsOK(res1)) {
49964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49965 }
49966 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49967 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49968 if (!SWIG_IsOK(res2)) {
49969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
49970 }
49971 {
49972 PyThreadState* __tstate = wxPyBeginAllowThreads();
49973 result = (wxGBSizerItem *)(arg1)->Add(arg2);
49974 wxPyEndAllowThreads(__tstate);
49975 if (PyErr_Occurred()) SWIG_fail;
49976 }
49977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49978 return resultobj;
49979 fail:
49980 return NULL;
49981 }
49982
49983
49984 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49985 PyObject *resultobj = 0;
49986 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49987 int arg2 ;
49988 int arg3 ;
49989 wxSize result;
49990 void *argp1 = 0 ;
49991 int res1 = 0 ;
49992 int val2 ;
49993 int ecode2 = 0 ;
49994 int val3 ;
49995 int ecode3 = 0 ;
49996 PyObject * obj0 = 0 ;
49997 PyObject * obj1 = 0 ;
49998 PyObject * obj2 = 0 ;
49999 char * kwnames[] = {
50000 (char *) "self",(char *) "row",(char *) "col", NULL
50001 };
50002
50003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50005 if (!SWIG_IsOK(res1)) {
50006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50007 }
50008 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50009 ecode2 = SWIG_AsVal_int(obj1, &val2);
50010 if (!SWIG_IsOK(ecode2)) {
50011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50012 }
50013 arg2 = static_cast< int >(val2);
50014 ecode3 = SWIG_AsVal_int(obj2, &val3);
50015 if (!SWIG_IsOK(ecode3)) {
50016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50017 }
50018 arg3 = static_cast< int >(val3);
50019 {
50020 PyThreadState* __tstate = wxPyBeginAllowThreads();
50021 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50022 wxPyEndAllowThreads(__tstate);
50023 if (PyErr_Occurred()) SWIG_fail;
50024 }
50025 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50026 return resultobj;
50027 fail:
50028 return NULL;
50029 }
50030
50031
50032 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50033 PyObject *resultobj = 0;
50034 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50035 wxSize result;
50036 void *argp1 = 0 ;
50037 int res1 = 0 ;
50038 PyObject *swig_obj[1] ;
50039
50040 if (!args) SWIG_fail;
50041 swig_obj[0] = args;
50042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50043 if (!SWIG_IsOK(res1)) {
50044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50045 }
50046 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50047 {
50048 PyThreadState* __tstate = wxPyBeginAllowThreads();
50049 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50050 wxPyEndAllowThreads(__tstate);
50051 if (PyErr_Occurred()) SWIG_fail;
50052 }
50053 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50054 return resultobj;
50055 fail:
50056 return NULL;
50057 }
50058
50059
50060 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50061 PyObject *resultobj = 0;
50062 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50063 wxSize *arg2 = 0 ;
50064 void *argp1 = 0 ;
50065 int res1 = 0 ;
50066 wxSize temp2 ;
50067 PyObject * obj0 = 0 ;
50068 PyObject * obj1 = 0 ;
50069 char * kwnames[] = {
50070 (char *) "self",(char *) "sz", NULL
50071 };
50072
50073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50075 if (!SWIG_IsOK(res1)) {
50076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50077 }
50078 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50079 {
50080 arg2 = &temp2;
50081 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50082 }
50083 {
50084 PyThreadState* __tstate = wxPyBeginAllowThreads();
50085 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50086 wxPyEndAllowThreads(__tstate);
50087 if (PyErr_Occurred()) SWIG_fail;
50088 }
50089 resultobj = SWIG_Py_Void();
50090 return resultobj;
50091 fail:
50092 return NULL;
50093 }
50094
50095
50096 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50097 PyObject *resultobj = 0;
50098 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50099 wxWindow *arg2 = (wxWindow *) 0 ;
50100 wxGBPosition result;
50101 void *argp1 = 0 ;
50102 int res1 = 0 ;
50103 void *argp2 = 0 ;
50104 int res2 = 0 ;
50105
50106 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50108 if (!SWIG_IsOK(res1)) {
50109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50110 }
50111 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50112 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50113 if (!SWIG_IsOK(res2)) {
50114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50115 }
50116 arg2 = reinterpret_cast< wxWindow * >(argp2);
50117 {
50118 PyThreadState* __tstate = wxPyBeginAllowThreads();
50119 result = (arg1)->GetItemPosition(arg2);
50120 wxPyEndAllowThreads(__tstate);
50121 if (PyErr_Occurred()) SWIG_fail;
50122 }
50123 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50124 return resultobj;
50125 fail:
50126 return NULL;
50127 }
50128
50129
50130 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50131 PyObject *resultobj = 0;
50132 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50133 wxSizer *arg2 = (wxSizer *) 0 ;
50134 wxGBPosition result;
50135 void *argp1 = 0 ;
50136 int res1 = 0 ;
50137 void *argp2 = 0 ;
50138 int res2 = 0 ;
50139
50140 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50142 if (!SWIG_IsOK(res1)) {
50143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50144 }
50145 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50146 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50147 if (!SWIG_IsOK(res2)) {
50148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50149 }
50150 arg2 = reinterpret_cast< wxSizer * >(argp2);
50151 {
50152 PyThreadState* __tstate = wxPyBeginAllowThreads();
50153 result = (arg1)->GetItemPosition(arg2);
50154 wxPyEndAllowThreads(__tstate);
50155 if (PyErr_Occurred()) SWIG_fail;
50156 }
50157 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50158 return resultobj;
50159 fail:
50160 return NULL;
50161 }
50162
50163
50164 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50165 PyObject *resultobj = 0;
50166 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50167 size_t arg2 ;
50168 wxGBPosition result;
50169 void *argp1 = 0 ;
50170 int res1 = 0 ;
50171 size_t val2 ;
50172 int ecode2 = 0 ;
50173
50174 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50176 if (!SWIG_IsOK(res1)) {
50177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50178 }
50179 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50180 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50181 if (!SWIG_IsOK(ecode2)) {
50182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50183 }
50184 arg2 = static_cast< size_t >(val2);
50185 {
50186 PyThreadState* __tstate = wxPyBeginAllowThreads();
50187 result = (arg1)->GetItemPosition(arg2);
50188 wxPyEndAllowThreads(__tstate);
50189 if (PyErr_Occurred()) SWIG_fail;
50190 }
50191 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50192 return resultobj;
50193 fail:
50194 return NULL;
50195 }
50196
50197
50198 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50199 int argc;
50200 PyObject *argv[3];
50201
50202 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50203 --argc;
50204 if (argc == 2) {
50205 int _v = 0;
50206 {
50207 void *vptr = 0;
50208 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50209 _v = SWIG_CheckState(res);
50210 }
50211 if (!_v) goto check_1;
50212 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50213 }
50214 check_1:
50215
50216 if (argc == 2) {
50217 int _v = 0;
50218 {
50219 void *vptr = 0;
50220 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50221 _v = SWIG_CheckState(res);
50222 }
50223 if (!_v) goto check_2;
50224 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50225 }
50226 check_2:
50227
50228 if (argc == 2) {
50229 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50230 }
50231
50232 fail:
50233 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50234 return NULL;
50235 }
50236
50237
50238 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50239 PyObject *resultobj = 0;
50240 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50241 wxWindow *arg2 = (wxWindow *) 0 ;
50242 wxGBPosition *arg3 = 0 ;
50243 bool result;
50244 void *argp1 = 0 ;
50245 int res1 = 0 ;
50246 void *argp2 = 0 ;
50247 int res2 = 0 ;
50248 wxGBPosition temp3 ;
50249
50250 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50252 if (!SWIG_IsOK(res1)) {
50253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50254 }
50255 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50256 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50257 if (!SWIG_IsOK(res2)) {
50258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50259 }
50260 arg2 = reinterpret_cast< wxWindow * >(argp2);
50261 {
50262 arg3 = &temp3;
50263 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50264 }
50265 {
50266 PyThreadState* __tstate = wxPyBeginAllowThreads();
50267 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50268 wxPyEndAllowThreads(__tstate);
50269 if (PyErr_Occurred()) SWIG_fail;
50270 }
50271 {
50272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50273 }
50274 return resultobj;
50275 fail:
50276 return NULL;
50277 }
50278
50279
50280 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50281 PyObject *resultobj = 0;
50282 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50283 wxSizer *arg2 = (wxSizer *) 0 ;
50284 wxGBPosition *arg3 = 0 ;
50285 bool result;
50286 void *argp1 = 0 ;
50287 int res1 = 0 ;
50288 void *argp2 = 0 ;
50289 int res2 = 0 ;
50290 wxGBPosition temp3 ;
50291
50292 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50294 if (!SWIG_IsOK(res1)) {
50295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50296 }
50297 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50298 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50299 if (!SWIG_IsOK(res2)) {
50300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50301 }
50302 arg2 = reinterpret_cast< wxSizer * >(argp2);
50303 {
50304 arg3 = &temp3;
50305 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50306 }
50307 {
50308 PyThreadState* __tstate = wxPyBeginAllowThreads();
50309 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50310 wxPyEndAllowThreads(__tstate);
50311 if (PyErr_Occurred()) SWIG_fail;
50312 }
50313 {
50314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50315 }
50316 return resultobj;
50317 fail:
50318 return NULL;
50319 }
50320
50321
50322 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50323 PyObject *resultobj = 0;
50324 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50325 size_t arg2 ;
50326 wxGBPosition *arg3 = 0 ;
50327 bool result;
50328 void *argp1 = 0 ;
50329 int res1 = 0 ;
50330 size_t val2 ;
50331 int ecode2 = 0 ;
50332 wxGBPosition temp3 ;
50333
50334 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50336 if (!SWIG_IsOK(res1)) {
50337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50338 }
50339 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50340 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50341 if (!SWIG_IsOK(ecode2)) {
50342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50343 }
50344 arg2 = static_cast< size_t >(val2);
50345 {
50346 arg3 = &temp3;
50347 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50348 }
50349 {
50350 PyThreadState* __tstate = wxPyBeginAllowThreads();
50351 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50352 wxPyEndAllowThreads(__tstate);
50353 if (PyErr_Occurred()) SWIG_fail;
50354 }
50355 {
50356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50357 }
50358 return resultobj;
50359 fail:
50360 return NULL;
50361 }
50362
50363
50364 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50365 int argc;
50366 PyObject *argv[4];
50367
50368 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50369 --argc;
50370 if (argc == 3) {
50371 int _v = 0;
50372 {
50373 void *vptr = 0;
50374 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50375 _v = SWIG_CheckState(res);
50376 }
50377 if (!_v) goto check_1;
50378 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50379 }
50380 check_1:
50381
50382 if (argc == 3) {
50383 int _v = 0;
50384 {
50385 void *vptr = 0;
50386 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50387 _v = SWIG_CheckState(res);
50388 }
50389 if (!_v) goto check_2;
50390 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50391 }
50392 check_2:
50393
50394 if (argc == 3) {
50395 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50396 }
50397
50398 fail:
50399 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50400 return NULL;
50401 }
50402
50403
50404 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50405 PyObject *resultobj = 0;
50406 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50407 wxWindow *arg2 = (wxWindow *) 0 ;
50408 wxGBSpan result;
50409 void *argp1 = 0 ;
50410 int res1 = 0 ;
50411 void *argp2 = 0 ;
50412 int res2 = 0 ;
50413
50414 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50416 if (!SWIG_IsOK(res1)) {
50417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50418 }
50419 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50420 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50421 if (!SWIG_IsOK(res2)) {
50422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50423 }
50424 arg2 = reinterpret_cast< wxWindow * >(argp2);
50425 {
50426 PyThreadState* __tstate = wxPyBeginAllowThreads();
50427 result = (arg1)->GetItemSpan(arg2);
50428 wxPyEndAllowThreads(__tstate);
50429 if (PyErr_Occurred()) SWIG_fail;
50430 }
50431 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50432 return resultobj;
50433 fail:
50434 return NULL;
50435 }
50436
50437
50438 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50439 PyObject *resultobj = 0;
50440 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50441 wxSizer *arg2 = (wxSizer *) 0 ;
50442 wxGBSpan result;
50443 void *argp1 = 0 ;
50444 int res1 = 0 ;
50445 void *argp2 = 0 ;
50446 int res2 = 0 ;
50447
50448 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50450 if (!SWIG_IsOK(res1)) {
50451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50452 }
50453 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50454 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50455 if (!SWIG_IsOK(res2)) {
50456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50457 }
50458 arg2 = reinterpret_cast< wxSizer * >(argp2);
50459 {
50460 PyThreadState* __tstate = wxPyBeginAllowThreads();
50461 result = (arg1)->GetItemSpan(arg2);
50462 wxPyEndAllowThreads(__tstate);
50463 if (PyErr_Occurred()) SWIG_fail;
50464 }
50465 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50466 return resultobj;
50467 fail:
50468 return NULL;
50469 }
50470
50471
50472 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50473 PyObject *resultobj = 0;
50474 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50475 size_t arg2 ;
50476 wxGBSpan result;
50477 void *argp1 = 0 ;
50478 int res1 = 0 ;
50479 size_t val2 ;
50480 int ecode2 = 0 ;
50481
50482 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50484 if (!SWIG_IsOK(res1)) {
50485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50486 }
50487 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50488 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50489 if (!SWIG_IsOK(ecode2)) {
50490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50491 }
50492 arg2 = static_cast< size_t >(val2);
50493 {
50494 PyThreadState* __tstate = wxPyBeginAllowThreads();
50495 result = (arg1)->GetItemSpan(arg2);
50496 wxPyEndAllowThreads(__tstate);
50497 if (PyErr_Occurred()) SWIG_fail;
50498 }
50499 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50500 return resultobj;
50501 fail:
50502 return NULL;
50503 }
50504
50505
50506 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50507 int argc;
50508 PyObject *argv[3];
50509
50510 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50511 --argc;
50512 if (argc == 2) {
50513 int _v = 0;
50514 {
50515 void *vptr = 0;
50516 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50517 _v = SWIG_CheckState(res);
50518 }
50519 if (!_v) goto check_1;
50520 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50521 }
50522 check_1:
50523
50524 if (argc == 2) {
50525 int _v = 0;
50526 {
50527 void *vptr = 0;
50528 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50529 _v = SWIG_CheckState(res);
50530 }
50531 if (!_v) goto check_2;
50532 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50533 }
50534 check_2:
50535
50536 if (argc == 2) {
50537 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50538 }
50539
50540 fail:
50541 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50542 return NULL;
50543 }
50544
50545
50546 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50547 PyObject *resultobj = 0;
50548 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50549 wxWindow *arg2 = (wxWindow *) 0 ;
50550 wxGBSpan *arg3 = 0 ;
50551 bool result;
50552 void *argp1 = 0 ;
50553 int res1 = 0 ;
50554 void *argp2 = 0 ;
50555 int res2 = 0 ;
50556 wxGBSpan temp3 ;
50557
50558 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50560 if (!SWIG_IsOK(res1)) {
50561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50562 }
50563 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50564 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50565 if (!SWIG_IsOK(res2)) {
50566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50567 }
50568 arg2 = reinterpret_cast< wxWindow * >(argp2);
50569 {
50570 arg3 = &temp3;
50571 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50572 }
50573 {
50574 PyThreadState* __tstate = wxPyBeginAllowThreads();
50575 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50576 wxPyEndAllowThreads(__tstate);
50577 if (PyErr_Occurred()) SWIG_fail;
50578 }
50579 {
50580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50581 }
50582 return resultobj;
50583 fail:
50584 return NULL;
50585 }
50586
50587
50588 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50589 PyObject *resultobj = 0;
50590 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50591 wxSizer *arg2 = (wxSizer *) 0 ;
50592 wxGBSpan *arg3 = 0 ;
50593 bool result;
50594 void *argp1 = 0 ;
50595 int res1 = 0 ;
50596 void *argp2 = 0 ;
50597 int res2 = 0 ;
50598 wxGBSpan temp3 ;
50599
50600 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50602 if (!SWIG_IsOK(res1)) {
50603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50604 }
50605 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50606 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50607 if (!SWIG_IsOK(res2)) {
50608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50609 }
50610 arg2 = reinterpret_cast< wxSizer * >(argp2);
50611 {
50612 arg3 = &temp3;
50613 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50614 }
50615 {
50616 PyThreadState* __tstate = wxPyBeginAllowThreads();
50617 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50618 wxPyEndAllowThreads(__tstate);
50619 if (PyErr_Occurred()) SWIG_fail;
50620 }
50621 {
50622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50623 }
50624 return resultobj;
50625 fail:
50626 return NULL;
50627 }
50628
50629
50630 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50631 PyObject *resultobj = 0;
50632 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50633 size_t arg2 ;
50634 wxGBSpan *arg3 = 0 ;
50635 bool result;
50636 void *argp1 = 0 ;
50637 int res1 = 0 ;
50638 size_t val2 ;
50639 int ecode2 = 0 ;
50640 wxGBSpan temp3 ;
50641
50642 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50644 if (!SWIG_IsOK(res1)) {
50645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50646 }
50647 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50648 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50649 if (!SWIG_IsOK(ecode2)) {
50650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50651 }
50652 arg2 = static_cast< size_t >(val2);
50653 {
50654 arg3 = &temp3;
50655 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50656 }
50657 {
50658 PyThreadState* __tstate = wxPyBeginAllowThreads();
50659 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50660 wxPyEndAllowThreads(__tstate);
50661 if (PyErr_Occurred()) SWIG_fail;
50662 }
50663 {
50664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50665 }
50666 return resultobj;
50667 fail:
50668 return NULL;
50669 }
50670
50671
50672 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50673 int argc;
50674 PyObject *argv[4];
50675
50676 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50677 --argc;
50678 if (argc == 3) {
50679 int _v = 0;
50680 {
50681 void *vptr = 0;
50682 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50683 _v = SWIG_CheckState(res);
50684 }
50685 if (!_v) goto check_1;
50686 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50687 }
50688 check_1:
50689
50690 if (argc == 3) {
50691 int _v = 0;
50692 {
50693 void *vptr = 0;
50694 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50695 _v = SWIG_CheckState(res);
50696 }
50697 if (!_v) goto check_2;
50698 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50699 }
50700 check_2:
50701
50702 if (argc == 3) {
50703 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50704 }
50705
50706 fail:
50707 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50708 return NULL;
50709 }
50710
50711
50712 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50713 PyObject *resultobj = 0;
50714 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50715 wxWindow *arg2 = (wxWindow *) 0 ;
50716 wxGBSizerItem *result = 0 ;
50717 void *argp1 = 0 ;
50718 int res1 = 0 ;
50719 void *argp2 = 0 ;
50720 int res2 = 0 ;
50721
50722 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50724 if (!SWIG_IsOK(res1)) {
50725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50726 }
50727 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50728 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50729 if (!SWIG_IsOK(res2)) {
50730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50731 }
50732 arg2 = reinterpret_cast< wxWindow * >(argp2);
50733 {
50734 PyThreadState* __tstate = wxPyBeginAllowThreads();
50735 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50736 wxPyEndAllowThreads(__tstate);
50737 if (PyErr_Occurred()) SWIG_fail;
50738 }
50739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50740 return resultobj;
50741 fail:
50742 return NULL;
50743 }
50744
50745
50746 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50747 PyObject *resultobj = 0;
50748 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50749 wxSizer *arg2 = (wxSizer *) 0 ;
50750 wxGBSizerItem *result = 0 ;
50751 void *argp1 = 0 ;
50752 int res1 = 0 ;
50753 void *argp2 = 0 ;
50754 int res2 = 0 ;
50755
50756 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50758 if (!SWIG_IsOK(res1)) {
50759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50760 }
50761 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50762 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50763 if (!SWIG_IsOK(res2)) {
50764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50765 }
50766 arg2 = reinterpret_cast< wxSizer * >(argp2);
50767 {
50768 PyThreadState* __tstate = wxPyBeginAllowThreads();
50769 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50770 wxPyEndAllowThreads(__tstate);
50771 if (PyErr_Occurred()) SWIG_fail;
50772 }
50773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50774 return resultobj;
50775 fail:
50776 return NULL;
50777 }
50778
50779
50780 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50781 int argc;
50782 PyObject *argv[3];
50783
50784 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50785 --argc;
50786 if (argc == 2) {
50787 int _v = 0;
50788 {
50789 void *vptr = 0;
50790 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50791 _v = SWIG_CheckState(res);
50792 }
50793 if (!_v) goto check_1;
50794 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50795 }
50796 check_1:
50797
50798 if (argc == 2) {
50799 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50800 }
50801
50802 fail:
50803 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50804 return NULL;
50805 }
50806
50807
50808 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50809 PyObject *resultobj = 0;
50810 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50811 wxGBPosition *arg2 = 0 ;
50812 wxGBSizerItem *result = 0 ;
50813 void *argp1 = 0 ;
50814 int res1 = 0 ;
50815 wxGBPosition temp2 ;
50816 PyObject * obj0 = 0 ;
50817 PyObject * obj1 = 0 ;
50818 char * kwnames[] = {
50819 (char *) "self",(char *) "pos", NULL
50820 };
50821
50822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50824 if (!SWIG_IsOK(res1)) {
50825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50826 }
50827 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50828 {
50829 arg2 = &temp2;
50830 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50831 }
50832 {
50833 PyThreadState* __tstate = wxPyBeginAllowThreads();
50834 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50835 wxPyEndAllowThreads(__tstate);
50836 if (PyErr_Occurred()) SWIG_fail;
50837 }
50838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50839 return resultobj;
50840 fail:
50841 return NULL;
50842 }
50843
50844
50845 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50846 PyObject *resultobj = 0;
50847 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50848 wxPoint *arg2 = 0 ;
50849 wxGBSizerItem *result = 0 ;
50850 void *argp1 = 0 ;
50851 int res1 = 0 ;
50852 wxPoint temp2 ;
50853 PyObject * obj0 = 0 ;
50854 PyObject * obj1 = 0 ;
50855 char * kwnames[] = {
50856 (char *) "self",(char *) "pt", NULL
50857 };
50858
50859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50861 if (!SWIG_IsOK(res1)) {
50862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50863 }
50864 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50865 {
50866 arg2 = &temp2;
50867 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50868 }
50869 {
50870 PyThreadState* __tstate = wxPyBeginAllowThreads();
50871 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50872 wxPyEndAllowThreads(__tstate);
50873 if (PyErr_Occurred()) SWIG_fail;
50874 }
50875 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50876 return resultobj;
50877 fail:
50878 return NULL;
50879 }
50880
50881
50882 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50883 PyObject *resultobj = 0;
50884 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50885 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50886 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50887 bool result;
50888 void *argp1 = 0 ;
50889 int res1 = 0 ;
50890 void *argp2 = 0 ;
50891 int res2 = 0 ;
50892 void *argp3 = 0 ;
50893 int res3 = 0 ;
50894 PyObject * obj0 = 0 ;
50895 PyObject * obj1 = 0 ;
50896 PyObject * obj2 = 0 ;
50897 char * kwnames[] = {
50898 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50899 };
50900
50901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50903 if (!SWIG_IsOK(res1)) {
50904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50905 }
50906 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50907 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50908 if (!SWIG_IsOK(res2)) {
50909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50910 }
50911 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50912 if (obj2) {
50913 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50914 if (!SWIG_IsOK(res3)) {
50915 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
50916 }
50917 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
50918 }
50919 {
50920 PyThreadState* __tstate = wxPyBeginAllowThreads();
50921 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
50922 wxPyEndAllowThreads(__tstate);
50923 if (PyErr_Occurred()) SWIG_fail;
50924 }
50925 {
50926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50927 }
50928 return resultobj;
50929 fail:
50930 return NULL;
50931 }
50932
50933
50934 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50935 PyObject *resultobj = 0;
50936 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50937 wxGBPosition *arg2 = 0 ;
50938 wxGBSpan *arg3 = 0 ;
50939 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
50940 bool result;
50941 void *argp1 = 0 ;
50942 int res1 = 0 ;
50943 wxGBPosition temp2 ;
50944 wxGBSpan temp3 ;
50945 void *argp4 = 0 ;
50946 int res4 = 0 ;
50947 PyObject * obj0 = 0 ;
50948 PyObject * obj1 = 0 ;
50949 PyObject * obj2 = 0 ;
50950 PyObject * obj3 = 0 ;
50951 char * kwnames[] = {
50952 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
50953 };
50954
50955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50957 if (!SWIG_IsOK(res1)) {
50958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50959 }
50960 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50961 {
50962 arg2 = &temp2;
50963 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50964 }
50965 {
50966 arg3 = &temp3;
50967 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50968 }
50969 if (obj3) {
50970 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50971 if (!SWIG_IsOK(res4)) {
50972 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
50973 }
50974 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
50975 }
50976 {
50977 PyThreadState* __tstate = wxPyBeginAllowThreads();
50978 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
50979 wxPyEndAllowThreads(__tstate);
50980 if (PyErr_Occurred()) SWIG_fail;
50981 }
50982 {
50983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50984 }
50985 return resultobj;
50986 fail:
50987 return NULL;
50988 }
50989
50990
50991 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50992 PyObject *obj;
50993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50994 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
50995 return SWIG_Py_Void();
50996 }
50997
50998 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50999 return SWIG_Python_InitShadowInstance(args);
51000 }
51001
51002 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51003 PyObject *resultobj = 0;
51004 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51005 wxRelationship arg2 ;
51006 wxWindow *arg3 = (wxWindow *) 0 ;
51007 wxEdge arg4 ;
51008 int arg5 = (int) 0 ;
51009 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51010 void *argp1 = 0 ;
51011 int res1 = 0 ;
51012 int val2 ;
51013 int ecode2 = 0 ;
51014 void *argp3 = 0 ;
51015 int res3 = 0 ;
51016 int val4 ;
51017 int ecode4 = 0 ;
51018 int val5 ;
51019 int ecode5 = 0 ;
51020 int val6 ;
51021 int ecode6 = 0 ;
51022 PyObject * obj0 = 0 ;
51023 PyObject * obj1 = 0 ;
51024 PyObject * obj2 = 0 ;
51025 PyObject * obj3 = 0 ;
51026 PyObject * obj4 = 0 ;
51027 PyObject * obj5 = 0 ;
51028 char * kwnames[] = {
51029 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51030 };
51031
51032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51034 if (!SWIG_IsOK(res1)) {
51035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51036 }
51037 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51038 ecode2 = SWIG_AsVal_int(obj1, &val2);
51039 if (!SWIG_IsOK(ecode2)) {
51040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51041 }
51042 arg2 = static_cast< wxRelationship >(val2);
51043 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51044 if (!SWIG_IsOK(res3)) {
51045 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51046 }
51047 arg3 = reinterpret_cast< wxWindow * >(argp3);
51048 ecode4 = SWIG_AsVal_int(obj3, &val4);
51049 if (!SWIG_IsOK(ecode4)) {
51050 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51051 }
51052 arg4 = static_cast< wxEdge >(val4);
51053 if (obj4) {
51054 ecode5 = SWIG_AsVal_int(obj4, &val5);
51055 if (!SWIG_IsOK(ecode5)) {
51056 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51057 }
51058 arg5 = static_cast< int >(val5);
51059 }
51060 if (obj5) {
51061 ecode6 = SWIG_AsVal_int(obj5, &val6);
51062 if (!SWIG_IsOK(ecode6)) {
51063 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51064 }
51065 arg6 = static_cast< int >(val6);
51066 }
51067 {
51068 PyThreadState* __tstate = wxPyBeginAllowThreads();
51069 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51070 wxPyEndAllowThreads(__tstate);
51071 if (PyErr_Occurred()) SWIG_fail;
51072 }
51073 resultobj = SWIG_Py_Void();
51074 return resultobj;
51075 fail:
51076 return NULL;
51077 }
51078
51079
51080 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51081 PyObject *resultobj = 0;
51082 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51083 wxWindow *arg2 = (wxWindow *) 0 ;
51084 int arg3 = (int) 0 ;
51085 void *argp1 = 0 ;
51086 int res1 = 0 ;
51087 void *argp2 = 0 ;
51088 int res2 = 0 ;
51089 int val3 ;
51090 int ecode3 = 0 ;
51091 PyObject * obj0 = 0 ;
51092 PyObject * obj1 = 0 ;
51093 PyObject * obj2 = 0 ;
51094 char * kwnames[] = {
51095 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51096 };
51097
51098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51100 if (!SWIG_IsOK(res1)) {
51101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51102 }
51103 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51104 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51105 if (!SWIG_IsOK(res2)) {
51106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51107 }
51108 arg2 = reinterpret_cast< wxWindow * >(argp2);
51109 if (obj2) {
51110 ecode3 = SWIG_AsVal_int(obj2, &val3);
51111 if (!SWIG_IsOK(ecode3)) {
51112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51113 }
51114 arg3 = static_cast< int >(val3);
51115 }
51116 {
51117 PyThreadState* __tstate = wxPyBeginAllowThreads();
51118 (arg1)->LeftOf(arg2,arg3);
51119 wxPyEndAllowThreads(__tstate);
51120 if (PyErr_Occurred()) SWIG_fail;
51121 }
51122 resultobj = SWIG_Py_Void();
51123 return resultobj;
51124 fail:
51125 return NULL;
51126 }
51127
51128
51129 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51130 PyObject *resultobj = 0;
51131 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51132 wxWindow *arg2 = (wxWindow *) 0 ;
51133 int arg3 = (int) 0 ;
51134 void *argp1 = 0 ;
51135 int res1 = 0 ;
51136 void *argp2 = 0 ;
51137 int res2 = 0 ;
51138 int val3 ;
51139 int ecode3 = 0 ;
51140 PyObject * obj0 = 0 ;
51141 PyObject * obj1 = 0 ;
51142 PyObject * obj2 = 0 ;
51143 char * kwnames[] = {
51144 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51145 };
51146
51147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51149 if (!SWIG_IsOK(res1)) {
51150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51151 }
51152 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51154 if (!SWIG_IsOK(res2)) {
51155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51156 }
51157 arg2 = reinterpret_cast< wxWindow * >(argp2);
51158 if (obj2) {
51159 ecode3 = SWIG_AsVal_int(obj2, &val3);
51160 if (!SWIG_IsOK(ecode3)) {
51161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51162 }
51163 arg3 = static_cast< int >(val3);
51164 }
51165 {
51166 PyThreadState* __tstate = wxPyBeginAllowThreads();
51167 (arg1)->RightOf(arg2,arg3);
51168 wxPyEndAllowThreads(__tstate);
51169 if (PyErr_Occurred()) SWIG_fail;
51170 }
51171 resultobj = SWIG_Py_Void();
51172 return resultobj;
51173 fail:
51174 return NULL;
51175 }
51176
51177
51178 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51179 PyObject *resultobj = 0;
51180 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51181 wxWindow *arg2 = (wxWindow *) 0 ;
51182 int arg3 = (int) 0 ;
51183 void *argp1 = 0 ;
51184 int res1 = 0 ;
51185 void *argp2 = 0 ;
51186 int res2 = 0 ;
51187 int val3 ;
51188 int ecode3 = 0 ;
51189 PyObject * obj0 = 0 ;
51190 PyObject * obj1 = 0 ;
51191 PyObject * obj2 = 0 ;
51192 char * kwnames[] = {
51193 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51194 };
51195
51196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51198 if (!SWIG_IsOK(res1)) {
51199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51200 }
51201 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51203 if (!SWIG_IsOK(res2)) {
51204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51205 }
51206 arg2 = reinterpret_cast< wxWindow * >(argp2);
51207 if (obj2) {
51208 ecode3 = SWIG_AsVal_int(obj2, &val3);
51209 if (!SWIG_IsOK(ecode3)) {
51210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51211 }
51212 arg3 = static_cast< int >(val3);
51213 }
51214 {
51215 PyThreadState* __tstate = wxPyBeginAllowThreads();
51216 (arg1)->Above(arg2,arg3);
51217 wxPyEndAllowThreads(__tstate);
51218 if (PyErr_Occurred()) SWIG_fail;
51219 }
51220 resultobj = SWIG_Py_Void();
51221 return resultobj;
51222 fail:
51223 return NULL;
51224 }
51225
51226
51227 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51228 PyObject *resultobj = 0;
51229 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51230 wxWindow *arg2 = (wxWindow *) 0 ;
51231 int arg3 = (int) 0 ;
51232 void *argp1 = 0 ;
51233 int res1 = 0 ;
51234 void *argp2 = 0 ;
51235 int res2 = 0 ;
51236 int val3 ;
51237 int ecode3 = 0 ;
51238 PyObject * obj0 = 0 ;
51239 PyObject * obj1 = 0 ;
51240 PyObject * obj2 = 0 ;
51241 char * kwnames[] = {
51242 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51243 };
51244
51245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51247 if (!SWIG_IsOK(res1)) {
51248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51249 }
51250 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51251 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51252 if (!SWIG_IsOK(res2)) {
51253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51254 }
51255 arg2 = reinterpret_cast< wxWindow * >(argp2);
51256 if (obj2) {
51257 ecode3 = SWIG_AsVal_int(obj2, &val3);
51258 if (!SWIG_IsOK(ecode3)) {
51259 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51260 }
51261 arg3 = static_cast< int >(val3);
51262 }
51263 {
51264 PyThreadState* __tstate = wxPyBeginAllowThreads();
51265 (arg1)->Below(arg2,arg3);
51266 wxPyEndAllowThreads(__tstate);
51267 if (PyErr_Occurred()) SWIG_fail;
51268 }
51269 resultobj = SWIG_Py_Void();
51270 return resultobj;
51271 fail:
51272 return NULL;
51273 }
51274
51275
51276 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51277 PyObject *resultobj = 0;
51278 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51279 wxWindow *arg2 = (wxWindow *) 0 ;
51280 wxEdge arg3 ;
51281 int arg4 = (int) 0 ;
51282 void *argp1 = 0 ;
51283 int res1 = 0 ;
51284 void *argp2 = 0 ;
51285 int res2 = 0 ;
51286 int val3 ;
51287 int ecode3 = 0 ;
51288 int val4 ;
51289 int ecode4 = 0 ;
51290 PyObject * obj0 = 0 ;
51291 PyObject * obj1 = 0 ;
51292 PyObject * obj2 = 0 ;
51293 PyObject * obj3 = 0 ;
51294 char * kwnames[] = {
51295 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51296 };
51297
51298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51300 if (!SWIG_IsOK(res1)) {
51301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51302 }
51303 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51304 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51305 if (!SWIG_IsOK(res2)) {
51306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51307 }
51308 arg2 = reinterpret_cast< wxWindow * >(argp2);
51309 ecode3 = SWIG_AsVal_int(obj2, &val3);
51310 if (!SWIG_IsOK(ecode3)) {
51311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51312 }
51313 arg3 = static_cast< wxEdge >(val3);
51314 if (obj3) {
51315 ecode4 = SWIG_AsVal_int(obj3, &val4);
51316 if (!SWIG_IsOK(ecode4)) {
51317 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51318 }
51319 arg4 = static_cast< int >(val4);
51320 }
51321 {
51322 PyThreadState* __tstate = wxPyBeginAllowThreads();
51323 (arg1)->SameAs(arg2,arg3,arg4);
51324 wxPyEndAllowThreads(__tstate);
51325 if (PyErr_Occurred()) SWIG_fail;
51326 }
51327 resultobj = SWIG_Py_Void();
51328 return resultobj;
51329 fail:
51330 return NULL;
51331 }
51332
51333
51334 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51335 PyObject *resultobj = 0;
51336 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51337 wxWindow *arg2 = (wxWindow *) 0 ;
51338 wxEdge arg3 ;
51339 int arg4 ;
51340 void *argp1 = 0 ;
51341 int res1 = 0 ;
51342 void *argp2 = 0 ;
51343 int res2 = 0 ;
51344 int val3 ;
51345 int ecode3 = 0 ;
51346 int val4 ;
51347 int ecode4 = 0 ;
51348 PyObject * obj0 = 0 ;
51349 PyObject * obj1 = 0 ;
51350 PyObject * obj2 = 0 ;
51351 PyObject * obj3 = 0 ;
51352 char * kwnames[] = {
51353 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51354 };
51355
51356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51358 if (!SWIG_IsOK(res1)) {
51359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51360 }
51361 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51363 if (!SWIG_IsOK(res2)) {
51364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51365 }
51366 arg2 = reinterpret_cast< wxWindow * >(argp2);
51367 ecode3 = SWIG_AsVal_int(obj2, &val3);
51368 if (!SWIG_IsOK(ecode3)) {
51369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51370 }
51371 arg3 = static_cast< wxEdge >(val3);
51372 ecode4 = SWIG_AsVal_int(obj3, &val4);
51373 if (!SWIG_IsOK(ecode4)) {
51374 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51375 }
51376 arg4 = static_cast< int >(val4);
51377 {
51378 PyThreadState* __tstate = wxPyBeginAllowThreads();
51379 (arg1)->PercentOf(arg2,arg3,arg4);
51380 wxPyEndAllowThreads(__tstate);
51381 if (PyErr_Occurred()) SWIG_fail;
51382 }
51383 resultobj = SWIG_Py_Void();
51384 return resultobj;
51385 fail:
51386 return NULL;
51387 }
51388
51389
51390 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51391 PyObject *resultobj = 0;
51392 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51393 int arg2 ;
51394 void *argp1 = 0 ;
51395 int res1 = 0 ;
51396 int val2 ;
51397 int ecode2 = 0 ;
51398 PyObject * obj0 = 0 ;
51399 PyObject * obj1 = 0 ;
51400 char * kwnames[] = {
51401 (char *) "self",(char *) "val", NULL
51402 };
51403
51404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51406 if (!SWIG_IsOK(res1)) {
51407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51408 }
51409 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51410 ecode2 = SWIG_AsVal_int(obj1, &val2);
51411 if (!SWIG_IsOK(ecode2)) {
51412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51413 }
51414 arg2 = static_cast< int >(val2);
51415 {
51416 PyThreadState* __tstate = wxPyBeginAllowThreads();
51417 (arg1)->Absolute(arg2);
51418 wxPyEndAllowThreads(__tstate);
51419 if (PyErr_Occurred()) SWIG_fail;
51420 }
51421 resultobj = SWIG_Py_Void();
51422 return resultobj;
51423 fail:
51424 return NULL;
51425 }
51426
51427
51428 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51429 PyObject *resultobj = 0;
51430 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51431 void *argp1 = 0 ;
51432 int res1 = 0 ;
51433 PyObject *swig_obj[1] ;
51434
51435 if (!args) SWIG_fail;
51436 swig_obj[0] = args;
51437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51438 if (!SWIG_IsOK(res1)) {
51439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51440 }
51441 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51442 {
51443 PyThreadState* __tstate = wxPyBeginAllowThreads();
51444 (arg1)->Unconstrained();
51445 wxPyEndAllowThreads(__tstate);
51446 if (PyErr_Occurred()) SWIG_fail;
51447 }
51448 resultobj = SWIG_Py_Void();
51449 return resultobj;
51450 fail:
51451 return NULL;
51452 }
51453
51454
51455 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51456 PyObject *resultobj = 0;
51457 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51458 void *argp1 = 0 ;
51459 int res1 = 0 ;
51460 PyObject *swig_obj[1] ;
51461
51462 if (!args) SWIG_fail;
51463 swig_obj[0] = args;
51464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51465 if (!SWIG_IsOK(res1)) {
51466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51467 }
51468 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51469 {
51470 PyThreadState* __tstate = wxPyBeginAllowThreads();
51471 (arg1)->AsIs();
51472 wxPyEndAllowThreads(__tstate);
51473 if (PyErr_Occurred()) SWIG_fail;
51474 }
51475 resultobj = SWIG_Py_Void();
51476 return resultobj;
51477 fail:
51478 return NULL;
51479 }
51480
51481
51482 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51483 PyObject *resultobj = 0;
51484 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51485 wxWindow *result = 0 ;
51486 void *argp1 = 0 ;
51487 int res1 = 0 ;
51488 PyObject *swig_obj[1] ;
51489
51490 if (!args) SWIG_fail;
51491 swig_obj[0] = args;
51492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51493 if (!SWIG_IsOK(res1)) {
51494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51495 }
51496 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51497 {
51498 PyThreadState* __tstate = wxPyBeginAllowThreads();
51499 result = (wxWindow *)(arg1)->GetOtherWindow();
51500 wxPyEndAllowThreads(__tstate);
51501 if (PyErr_Occurred()) SWIG_fail;
51502 }
51503 {
51504 resultobj = wxPyMake_wxObject(result, 0);
51505 }
51506 return resultobj;
51507 fail:
51508 return NULL;
51509 }
51510
51511
51512 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51513 PyObject *resultobj = 0;
51514 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51515 wxEdge result;
51516 void *argp1 = 0 ;
51517 int res1 = 0 ;
51518 PyObject *swig_obj[1] ;
51519
51520 if (!args) SWIG_fail;
51521 swig_obj[0] = args;
51522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51523 if (!SWIG_IsOK(res1)) {
51524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51525 }
51526 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51527 {
51528 PyThreadState* __tstate = wxPyBeginAllowThreads();
51529 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51530 wxPyEndAllowThreads(__tstate);
51531 if (PyErr_Occurred()) SWIG_fail;
51532 }
51533 resultobj = SWIG_From_int(static_cast< int >(result));
51534 return resultobj;
51535 fail:
51536 return NULL;
51537 }
51538
51539
51540 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51541 PyObject *resultobj = 0;
51542 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51543 wxEdge arg2 ;
51544 void *argp1 = 0 ;
51545 int res1 = 0 ;
51546 int val2 ;
51547 int ecode2 = 0 ;
51548 PyObject * obj0 = 0 ;
51549 PyObject * obj1 = 0 ;
51550 char * kwnames[] = {
51551 (char *) "self",(char *) "which", NULL
51552 };
51553
51554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51556 if (!SWIG_IsOK(res1)) {
51557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51558 }
51559 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51560 ecode2 = SWIG_AsVal_int(obj1, &val2);
51561 if (!SWIG_IsOK(ecode2)) {
51562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51563 }
51564 arg2 = static_cast< wxEdge >(val2);
51565 {
51566 PyThreadState* __tstate = wxPyBeginAllowThreads();
51567 (arg1)->SetEdge(arg2);
51568 wxPyEndAllowThreads(__tstate);
51569 if (PyErr_Occurred()) SWIG_fail;
51570 }
51571 resultobj = SWIG_Py_Void();
51572 return resultobj;
51573 fail:
51574 return NULL;
51575 }
51576
51577
51578 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51579 PyObject *resultobj = 0;
51580 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51581 int arg2 ;
51582 void *argp1 = 0 ;
51583 int res1 = 0 ;
51584 int val2 ;
51585 int ecode2 = 0 ;
51586 PyObject * obj0 = 0 ;
51587 PyObject * obj1 = 0 ;
51588 char * kwnames[] = {
51589 (char *) "self",(char *) "v", NULL
51590 };
51591
51592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51594 if (!SWIG_IsOK(res1)) {
51595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51596 }
51597 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51598 ecode2 = SWIG_AsVal_int(obj1, &val2);
51599 if (!SWIG_IsOK(ecode2)) {
51600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51601 }
51602 arg2 = static_cast< int >(val2);
51603 {
51604 PyThreadState* __tstate = wxPyBeginAllowThreads();
51605 (arg1)->SetValue(arg2);
51606 wxPyEndAllowThreads(__tstate);
51607 if (PyErr_Occurred()) SWIG_fail;
51608 }
51609 resultobj = SWIG_Py_Void();
51610 return resultobj;
51611 fail:
51612 return NULL;
51613 }
51614
51615
51616 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51617 PyObject *resultobj = 0;
51618 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51619 int result;
51620 void *argp1 = 0 ;
51621 int res1 = 0 ;
51622 PyObject *swig_obj[1] ;
51623
51624 if (!args) SWIG_fail;
51625 swig_obj[0] = args;
51626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51627 if (!SWIG_IsOK(res1)) {
51628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51629 }
51630 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51631 {
51632 PyThreadState* __tstate = wxPyBeginAllowThreads();
51633 result = (int)(arg1)->GetMargin();
51634 wxPyEndAllowThreads(__tstate);
51635 if (PyErr_Occurred()) SWIG_fail;
51636 }
51637 resultobj = SWIG_From_int(static_cast< int >(result));
51638 return resultobj;
51639 fail:
51640 return NULL;
51641 }
51642
51643
51644 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51645 PyObject *resultobj = 0;
51646 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51647 int arg2 ;
51648 void *argp1 = 0 ;
51649 int res1 = 0 ;
51650 int val2 ;
51651 int ecode2 = 0 ;
51652 PyObject * obj0 = 0 ;
51653 PyObject * obj1 = 0 ;
51654 char * kwnames[] = {
51655 (char *) "self",(char *) "m", NULL
51656 };
51657
51658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51660 if (!SWIG_IsOK(res1)) {
51661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51662 }
51663 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51664 ecode2 = SWIG_AsVal_int(obj1, &val2);
51665 if (!SWIG_IsOK(ecode2)) {
51666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51667 }
51668 arg2 = static_cast< int >(val2);
51669 {
51670 PyThreadState* __tstate = wxPyBeginAllowThreads();
51671 (arg1)->SetMargin(arg2);
51672 wxPyEndAllowThreads(__tstate);
51673 if (PyErr_Occurred()) SWIG_fail;
51674 }
51675 resultobj = SWIG_Py_Void();
51676 return resultobj;
51677 fail:
51678 return NULL;
51679 }
51680
51681
51682 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51683 PyObject *resultobj = 0;
51684 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51685 int result;
51686 void *argp1 = 0 ;
51687 int res1 = 0 ;
51688 PyObject *swig_obj[1] ;
51689
51690 if (!args) SWIG_fail;
51691 swig_obj[0] = args;
51692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51693 if (!SWIG_IsOK(res1)) {
51694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51695 }
51696 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51697 {
51698 PyThreadState* __tstate = wxPyBeginAllowThreads();
51699 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51700 wxPyEndAllowThreads(__tstate);
51701 if (PyErr_Occurred()) SWIG_fail;
51702 }
51703 resultobj = SWIG_From_int(static_cast< int >(result));
51704 return resultobj;
51705 fail:
51706 return NULL;
51707 }
51708
51709
51710 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51711 PyObject *resultobj = 0;
51712 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51713 int result;
51714 void *argp1 = 0 ;
51715 int res1 = 0 ;
51716 PyObject *swig_obj[1] ;
51717
51718 if (!args) SWIG_fail;
51719 swig_obj[0] = args;
51720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51721 if (!SWIG_IsOK(res1)) {
51722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51723 }
51724 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51725 {
51726 PyThreadState* __tstate = wxPyBeginAllowThreads();
51727 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51728 wxPyEndAllowThreads(__tstate);
51729 if (PyErr_Occurred()) SWIG_fail;
51730 }
51731 resultobj = SWIG_From_int(static_cast< int >(result));
51732 return resultobj;
51733 fail:
51734 return NULL;
51735 }
51736
51737
51738 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51739 PyObject *resultobj = 0;
51740 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51741 int result;
51742 void *argp1 = 0 ;
51743 int res1 = 0 ;
51744 PyObject *swig_obj[1] ;
51745
51746 if (!args) SWIG_fail;
51747 swig_obj[0] = args;
51748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51749 if (!SWIG_IsOK(res1)) {
51750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51751 }
51752 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51753 {
51754 PyThreadState* __tstate = wxPyBeginAllowThreads();
51755 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51756 wxPyEndAllowThreads(__tstate);
51757 if (PyErr_Occurred()) SWIG_fail;
51758 }
51759 resultobj = SWIG_From_int(static_cast< int >(result));
51760 return resultobj;
51761 fail:
51762 return NULL;
51763 }
51764
51765
51766 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51767 PyObject *resultobj = 0;
51768 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51769 bool result;
51770 void *argp1 = 0 ;
51771 int res1 = 0 ;
51772 PyObject *swig_obj[1] ;
51773
51774 if (!args) SWIG_fail;
51775 swig_obj[0] = args;
51776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51777 if (!SWIG_IsOK(res1)) {
51778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51779 }
51780 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51781 {
51782 PyThreadState* __tstate = wxPyBeginAllowThreads();
51783 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51784 wxPyEndAllowThreads(__tstate);
51785 if (PyErr_Occurred()) SWIG_fail;
51786 }
51787 {
51788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51789 }
51790 return resultobj;
51791 fail:
51792 return NULL;
51793 }
51794
51795
51796 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51797 PyObject *resultobj = 0;
51798 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51799 bool arg2 ;
51800 void *argp1 = 0 ;
51801 int res1 = 0 ;
51802 bool val2 ;
51803 int ecode2 = 0 ;
51804 PyObject * obj0 = 0 ;
51805 PyObject * obj1 = 0 ;
51806 char * kwnames[] = {
51807 (char *) "self",(char *) "d", NULL
51808 };
51809
51810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51812 if (!SWIG_IsOK(res1)) {
51813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51814 }
51815 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51816 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51817 if (!SWIG_IsOK(ecode2)) {
51818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51819 }
51820 arg2 = static_cast< bool >(val2);
51821 {
51822 PyThreadState* __tstate = wxPyBeginAllowThreads();
51823 (arg1)->SetDone(arg2);
51824 wxPyEndAllowThreads(__tstate);
51825 if (PyErr_Occurred()) SWIG_fail;
51826 }
51827 resultobj = SWIG_Py_Void();
51828 return resultobj;
51829 fail:
51830 return NULL;
51831 }
51832
51833
51834 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51835 PyObject *resultobj = 0;
51836 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51837 wxRelationship result;
51838 void *argp1 = 0 ;
51839 int res1 = 0 ;
51840 PyObject *swig_obj[1] ;
51841
51842 if (!args) SWIG_fail;
51843 swig_obj[0] = args;
51844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51845 if (!SWIG_IsOK(res1)) {
51846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51847 }
51848 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51849 {
51850 PyThreadState* __tstate = wxPyBeginAllowThreads();
51851 result = (wxRelationship)(arg1)->GetRelationship();
51852 wxPyEndAllowThreads(__tstate);
51853 if (PyErr_Occurred()) SWIG_fail;
51854 }
51855 resultobj = SWIG_From_int(static_cast< int >(result));
51856 return resultobj;
51857 fail:
51858 return NULL;
51859 }
51860
51861
51862 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51863 PyObject *resultobj = 0;
51864 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51865 wxRelationship arg2 ;
51866 void *argp1 = 0 ;
51867 int res1 = 0 ;
51868 int val2 ;
51869 int ecode2 = 0 ;
51870 PyObject * obj0 = 0 ;
51871 PyObject * obj1 = 0 ;
51872 char * kwnames[] = {
51873 (char *) "self",(char *) "r", NULL
51874 };
51875
51876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51878 if (!SWIG_IsOK(res1)) {
51879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51880 }
51881 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51882 ecode2 = SWIG_AsVal_int(obj1, &val2);
51883 if (!SWIG_IsOK(ecode2)) {
51884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51885 }
51886 arg2 = static_cast< wxRelationship >(val2);
51887 {
51888 PyThreadState* __tstate = wxPyBeginAllowThreads();
51889 (arg1)->SetRelationship(arg2);
51890 wxPyEndAllowThreads(__tstate);
51891 if (PyErr_Occurred()) SWIG_fail;
51892 }
51893 resultobj = SWIG_Py_Void();
51894 return resultobj;
51895 fail:
51896 return NULL;
51897 }
51898
51899
51900 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51901 PyObject *resultobj = 0;
51902 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51903 wxWindow *arg2 = (wxWindow *) 0 ;
51904 bool result;
51905 void *argp1 = 0 ;
51906 int res1 = 0 ;
51907 void *argp2 = 0 ;
51908 int res2 = 0 ;
51909 PyObject * obj0 = 0 ;
51910 PyObject * obj1 = 0 ;
51911 char * kwnames[] = {
51912 (char *) "self",(char *) "otherW", NULL
51913 };
51914
51915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
51916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51917 if (!SWIG_IsOK(res1)) {
51918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51919 }
51920 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51921 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51922 if (!SWIG_IsOK(res2)) {
51923 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51924 }
51925 arg2 = reinterpret_cast< wxWindow * >(argp2);
51926 {
51927 PyThreadState* __tstate = wxPyBeginAllowThreads();
51928 result = (bool)(arg1)->ResetIfWin(arg2);
51929 wxPyEndAllowThreads(__tstate);
51930 if (PyErr_Occurred()) SWIG_fail;
51931 }
51932 {
51933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51934 }
51935 return resultobj;
51936 fail:
51937 return NULL;
51938 }
51939
51940
51941 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51942 PyObject *resultobj = 0;
51943 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51944 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
51945 wxWindow *arg3 = (wxWindow *) 0 ;
51946 bool result;
51947 void *argp1 = 0 ;
51948 int res1 = 0 ;
51949 void *argp2 = 0 ;
51950 int res2 = 0 ;
51951 void *argp3 = 0 ;
51952 int res3 = 0 ;
51953 PyObject * obj0 = 0 ;
51954 PyObject * obj1 = 0 ;
51955 PyObject * obj2 = 0 ;
51956 char * kwnames[] = {
51957 (char *) "self",(char *) "constraints",(char *) "win", NULL
51958 };
51959
51960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51962 if (!SWIG_IsOK(res1)) {
51963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51964 }
51965 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51966 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51967 if (!SWIG_IsOK(res2)) {
51968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
51969 }
51970 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
51971 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51972 if (!SWIG_IsOK(res3)) {
51973 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
51974 }
51975 arg3 = reinterpret_cast< wxWindow * >(argp3);
51976 {
51977 PyThreadState* __tstate = wxPyBeginAllowThreads();
51978 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
51979 wxPyEndAllowThreads(__tstate);
51980 if (PyErr_Occurred()) SWIG_fail;
51981 }
51982 {
51983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51984 }
51985 return resultobj;
51986 fail:
51987 return NULL;
51988 }
51989
51990
51991 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51992 PyObject *resultobj = 0;
51993 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51994 wxEdge arg2 ;
51995 wxWindow *arg3 = (wxWindow *) 0 ;
51996 wxWindow *arg4 = (wxWindow *) 0 ;
51997 int result;
51998 void *argp1 = 0 ;
51999 int res1 = 0 ;
52000 int val2 ;
52001 int ecode2 = 0 ;
52002 void *argp3 = 0 ;
52003 int res3 = 0 ;
52004 void *argp4 = 0 ;
52005 int res4 = 0 ;
52006 PyObject * obj0 = 0 ;
52007 PyObject * obj1 = 0 ;
52008 PyObject * obj2 = 0 ;
52009 PyObject * obj3 = 0 ;
52010 char * kwnames[] = {
52011 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52012 };
52013
52014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52016 if (!SWIG_IsOK(res1)) {
52017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52018 }
52019 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52020 ecode2 = SWIG_AsVal_int(obj1, &val2);
52021 if (!SWIG_IsOK(ecode2)) {
52022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52023 }
52024 arg2 = static_cast< wxEdge >(val2);
52025 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52026 if (!SWIG_IsOK(res3)) {
52027 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52028 }
52029 arg3 = reinterpret_cast< wxWindow * >(argp3);
52030 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52031 if (!SWIG_IsOK(res4)) {
52032 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52033 }
52034 arg4 = reinterpret_cast< wxWindow * >(argp4);
52035 {
52036 PyThreadState* __tstate = wxPyBeginAllowThreads();
52037 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52038 wxPyEndAllowThreads(__tstate);
52039 if (PyErr_Occurred()) SWIG_fail;
52040 }
52041 resultobj = SWIG_From_int(static_cast< int >(result));
52042 return resultobj;
52043 fail:
52044 return NULL;
52045 }
52046
52047
52048 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52049 PyObject *obj;
52050 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52051 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52052 return SWIG_Py_Void();
52053 }
52054
52055 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52056 PyObject *resultobj = 0;
52057 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52058 wxIndividualLayoutConstraint *result = 0 ;
52059 void *argp1 = 0 ;
52060 int res1 = 0 ;
52061 PyObject *swig_obj[1] ;
52062
52063 if (!args) SWIG_fail;
52064 swig_obj[0] = args;
52065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52066 if (!SWIG_IsOK(res1)) {
52067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52068 }
52069 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52070 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52071 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52072 return resultobj;
52073 fail:
52074 return NULL;
52075 }
52076
52077
52078 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52079 PyObject *resultobj = 0;
52080 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52081 wxIndividualLayoutConstraint *result = 0 ;
52082 void *argp1 = 0 ;
52083 int res1 = 0 ;
52084 PyObject *swig_obj[1] ;
52085
52086 if (!args) SWIG_fail;
52087 swig_obj[0] = args;
52088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52089 if (!SWIG_IsOK(res1)) {
52090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52091 }
52092 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52093 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52095 return resultobj;
52096 fail:
52097 return NULL;
52098 }
52099
52100
52101 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52102 PyObject *resultobj = 0;
52103 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52104 wxIndividualLayoutConstraint *result = 0 ;
52105 void *argp1 = 0 ;
52106 int res1 = 0 ;
52107 PyObject *swig_obj[1] ;
52108
52109 if (!args) SWIG_fail;
52110 swig_obj[0] = args;
52111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52112 if (!SWIG_IsOK(res1)) {
52113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52114 }
52115 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52116 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52118 return resultobj;
52119 fail:
52120 return NULL;
52121 }
52122
52123
52124 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52125 PyObject *resultobj = 0;
52126 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52127 wxIndividualLayoutConstraint *result = 0 ;
52128 void *argp1 = 0 ;
52129 int res1 = 0 ;
52130 PyObject *swig_obj[1] ;
52131
52132 if (!args) SWIG_fail;
52133 swig_obj[0] = args;
52134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52135 if (!SWIG_IsOK(res1)) {
52136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52137 }
52138 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52139 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52141 return resultobj;
52142 fail:
52143 return NULL;
52144 }
52145
52146
52147 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52148 PyObject *resultobj = 0;
52149 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52150 wxIndividualLayoutConstraint *result = 0 ;
52151 void *argp1 = 0 ;
52152 int res1 = 0 ;
52153 PyObject *swig_obj[1] ;
52154
52155 if (!args) SWIG_fail;
52156 swig_obj[0] = args;
52157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52158 if (!SWIG_IsOK(res1)) {
52159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52160 }
52161 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52162 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52164 return resultobj;
52165 fail:
52166 return NULL;
52167 }
52168
52169
52170 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52171 PyObject *resultobj = 0;
52172 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52173 wxIndividualLayoutConstraint *result = 0 ;
52174 void *argp1 = 0 ;
52175 int res1 = 0 ;
52176 PyObject *swig_obj[1] ;
52177
52178 if (!args) SWIG_fail;
52179 swig_obj[0] = args;
52180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52181 if (!SWIG_IsOK(res1)) {
52182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52183 }
52184 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52185 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52187 return resultobj;
52188 fail:
52189 return NULL;
52190 }
52191
52192
52193 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52194 PyObject *resultobj = 0;
52195 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52196 wxIndividualLayoutConstraint *result = 0 ;
52197 void *argp1 = 0 ;
52198 int res1 = 0 ;
52199 PyObject *swig_obj[1] ;
52200
52201 if (!args) SWIG_fail;
52202 swig_obj[0] = args;
52203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52204 if (!SWIG_IsOK(res1)) {
52205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52206 }
52207 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52208 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52210 return resultobj;
52211 fail:
52212 return NULL;
52213 }
52214
52215
52216 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52217 PyObject *resultobj = 0;
52218 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52219 wxIndividualLayoutConstraint *result = 0 ;
52220 void *argp1 = 0 ;
52221 int res1 = 0 ;
52222 PyObject *swig_obj[1] ;
52223
52224 if (!args) SWIG_fail;
52225 swig_obj[0] = args;
52226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52227 if (!SWIG_IsOK(res1)) {
52228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52229 }
52230 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52231 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52233 return resultobj;
52234 fail:
52235 return NULL;
52236 }
52237
52238
52239 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52240 PyObject *resultobj = 0;
52241 wxLayoutConstraints *result = 0 ;
52242
52243 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52244 {
52245 PyThreadState* __tstate = wxPyBeginAllowThreads();
52246 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52247 wxPyEndAllowThreads(__tstate);
52248 if (PyErr_Occurred()) SWIG_fail;
52249 }
52250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52251 return resultobj;
52252 fail:
52253 return NULL;
52254 }
52255
52256
52257 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52258 PyObject *resultobj = 0;
52259 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52260 void *argp1 = 0 ;
52261 int res1 = 0 ;
52262 PyObject *swig_obj[1] ;
52263
52264 if (!args) SWIG_fail;
52265 swig_obj[0] = args;
52266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52267 if (!SWIG_IsOK(res1)) {
52268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52269 }
52270 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52271 {
52272 PyThreadState* __tstate = wxPyBeginAllowThreads();
52273 delete arg1;
52274
52275 wxPyEndAllowThreads(__tstate);
52276 if (PyErr_Occurred()) SWIG_fail;
52277 }
52278 resultobj = SWIG_Py_Void();
52279 return resultobj;
52280 fail:
52281 return NULL;
52282 }
52283
52284
52285 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52286 PyObject *resultobj = 0;
52287 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52288 wxWindow *arg2 = (wxWindow *) 0 ;
52289 int *arg3 = (int *) 0 ;
52290 bool result;
52291 void *argp1 = 0 ;
52292 int res1 = 0 ;
52293 void *argp2 = 0 ;
52294 int res2 = 0 ;
52295 int temp3 ;
52296 int res3 = SWIG_TMPOBJ ;
52297 PyObject * obj0 = 0 ;
52298 PyObject * obj1 = 0 ;
52299 char * kwnames[] = {
52300 (char *) "self",(char *) "win", NULL
52301 };
52302
52303 arg3 = &temp3;
52304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52306 if (!SWIG_IsOK(res1)) {
52307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52308 }
52309 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52310 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52311 if (!SWIG_IsOK(res2)) {
52312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52313 }
52314 arg2 = reinterpret_cast< wxWindow * >(argp2);
52315 {
52316 PyThreadState* __tstate = wxPyBeginAllowThreads();
52317 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52318 wxPyEndAllowThreads(__tstate);
52319 if (PyErr_Occurred()) SWIG_fail;
52320 }
52321 {
52322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52323 }
52324 if (SWIG_IsTmpObj(res3)) {
52325 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52326 } else {
52327 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52328 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52329 }
52330 return resultobj;
52331 fail:
52332 return NULL;
52333 }
52334
52335
52336 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52337 PyObject *resultobj = 0;
52338 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52339 bool result;
52340 void *argp1 = 0 ;
52341 int res1 = 0 ;
52342 PyObject *swig_obj[1] ;
52343
52344 if (!args) SWIG_fail;
52345 swig_obj[0] = args;
52346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52347 if (!SWIG_IsOK(res1)) {
52348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52349 }
52350 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52351 {
52352 PyThreadState* __tstate = wxPyBeginAllowThreads();
52353 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52354 wxPyEndAllowThreads(__tstate);
52355 if (PyErr_Occurred()) SWIG_fail;
52356 }
52357 {
52358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52359 }
52360 return resultobj;
52361 fail:
52362 return NULL;
52363 }
52364
52365
52366 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52367 PyObject *obj;
52368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52369 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52370 return SWIG_Py_Void();
52371 }
52372
52373 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52374 return SWIG_Python_InitShadowInstance(args);
52375 }
52376
52377 static PyMethodDef SwigMethods[] = {
52378 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52379 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
52380 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52381 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52382 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52383 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52384 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52385 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52386 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52387 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52388 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52389 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52390 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52391 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52392 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52393 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52394 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52395 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52396 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52397 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52398 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52399 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52400 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52401 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52402 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52403 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52404 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52405 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52406 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52407 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52408 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52409 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52410 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52411 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52412 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52413 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52414 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52415 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52416 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52417 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52418 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52419 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52420 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52421 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52422 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52423 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52424 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52425 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52426 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52427 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52428 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52429 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52430 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52431 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52432 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52433 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52434 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52435 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52436 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52437 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52438 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52439 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52440 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52441 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52442 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52443 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52444 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52445 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52446 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52447 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52448 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52449 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52450 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52451 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52452 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52453 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52454 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52455 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52456 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52457 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52458 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52459 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52460 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52461 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52462 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52463 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52464 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52465 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52466 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52467 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52468 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52469 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52470 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52471 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52472 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52473 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52474 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52475 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52476 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52477 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52478 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52479 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52480 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52481 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52482 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52483 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52484 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52485 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52486 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52487 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52488 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52489 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52490 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52491 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52492 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52493 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52494 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52495 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52496 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52497 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52498 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52499 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52500 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52501 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52502 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52503 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52504 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52505 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52506 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52507 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52508 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52509 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52510 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52511 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52512 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52513 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52514 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52515 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52516 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52517 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52518 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52519 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52520 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52521 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52522 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52523 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52524 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52525 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52526 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52527 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52528 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52529 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52530 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52531 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52532 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52533 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52534 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52535 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52536 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52538 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52539 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52540 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52541 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52542 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52543 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52544 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52545 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52546 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52547 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52548 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52549 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52550 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52551 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52552 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52553 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52554 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52555 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52556 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52557 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52558 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52559 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52560 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52563 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52564 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52565 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52566 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52567 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52568 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52569 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52571 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52572 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52573 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52574 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52575 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52576 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52577 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52578 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52579 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52580 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52581 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52582 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52584 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52585 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52586 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52587 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52589 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52590 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52591 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52592 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52594 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52596 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52597 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52598 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52600 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52601 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52602 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52603 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52604 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52605 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52606 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52607 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52608 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52609 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52610 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52611 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52613 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52614 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52616 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52617 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52618 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52624 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52625 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52627 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52628 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52629 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52630 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52631 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52632 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52633 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52634 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52636 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52637 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52638 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52639 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52640 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52641 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52642 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52643 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52645 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52646 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52647 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52648 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52649 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52654 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52657 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52659 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52660 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52662 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52663 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52666 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52667 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52668 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52669 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52670 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52671 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52672 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52673 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52675 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52677 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52682 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52683 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52684 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52685 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52688 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52690 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52692 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52694 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52695 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52696 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52697 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52698 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52699 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52700 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52701 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52702 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52703 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52704 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52705 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52706 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52707 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52708 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52709 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52710 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52711 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52716 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52717 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52718 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52719 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52720 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52721 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52722 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52723 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52724 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52725 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52726 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52727 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52728 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52729 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52730 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52731 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52732 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52733 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52734 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52735 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52736 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52737 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52738 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52739 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52740 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52741 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52742 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52743 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52744 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52745 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52746 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52747 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52748 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52749 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52750 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52751 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52752 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52753 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52754 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52755 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52756 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52757 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52758 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52759 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52760 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52761 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52762 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52764 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52765 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52766 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52767 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52770 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52772 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52774 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52776 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52777 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52778 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52779 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52780 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52781 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52782 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52783 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52784 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52786 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52788 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52789 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52790 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52791 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52792 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52793 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52794 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52796 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52797 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52799 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52800 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52801 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52802 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52803 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52804 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52805 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52807 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52809 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52810 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52811 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52813 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52815 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52816 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52818 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52819 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52820 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52822 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52823 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52824 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52825 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52826 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52827 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52828 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52829 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52830 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52831 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52832 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52833 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52835 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52836 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52839 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52840 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52842 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52848 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52849 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52850 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52851 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52852 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52853 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52854 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52855 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52856 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52857 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52858 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52859 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52860 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52861 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52862 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52863 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52864 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52865 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52866 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52867 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52868 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52869 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52870 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52871 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52873 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52874 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52875 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52876 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52877 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52878 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52879 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52880 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52881 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52882 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52883 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52884 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52885 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52886 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52887 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52888 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52889 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52890 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52891 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52892 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52893 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52894 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52895 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52896 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52897 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52898 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52899 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52900 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52901 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52902 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52903 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52904 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52906 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52907 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52908 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
52909 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
52910 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
52911 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
52912 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
52914 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
52915 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
52916 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
52917 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
52918 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
52919 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
52920 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
52921 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
52922 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
52923 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
52924 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
52925 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
52926 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
52927 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
52928 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
52929 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
52930 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
52931 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
52932 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
52933 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
52934 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
52935 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
52936 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
52937 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
52938 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
52939 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
52940 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
52941 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
52942 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
52943 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
52944 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
52945 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
52946 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
52947 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
52948 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
52949 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
52950 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
52952 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
52953 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
52956 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
52957 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
52958 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
52959 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
52960 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
52961 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
52963 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
52964 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52966 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
52967 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
52968 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52969 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
52970 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
52971 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52972 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
52973 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
52974 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
52976 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
52977 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
52978 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
52980 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
52982 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
52983 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
52985 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
52986 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
52987 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
52989 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
52990 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
52991 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
52993 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
52994 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
52996 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
52997 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
52998 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
52999 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53000 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53002 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53003 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53004 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53005 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53007 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53008 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53009 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53012 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53013 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53014 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53015 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53016 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53017 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53018 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53019 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53020 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53021 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53022 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53023 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53024 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53025 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53026 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53027 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53028 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53029 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53030 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53031 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53032 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53033 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53034 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53037 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53038 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53040 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53041 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53042 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53044 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53045 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53046 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53047 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53048 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53049 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53050 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53051 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53052 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53053 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53054 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53055 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53056 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53057 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53059 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53060 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53061 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53063 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53064 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53065 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53066 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53067 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53068 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53069 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53070 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53072 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53075 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53077 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53078 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53080 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53081 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53082 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53084 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53085 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53086 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53088 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53090 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53091 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53092 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53094 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53096 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53098 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53099 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53101 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53103 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53104 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53105 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53106 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53107 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53108 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53109 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53110 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53111 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53113 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53115 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53116 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53117 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53118 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53120 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53122 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53123 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53124 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53125 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53126 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53127 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53129 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53130 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53131 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53132 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53133 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53134 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53135 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53136 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53138 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53140 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53142 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53144 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53145 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53146 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53148 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53149 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53150 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53151 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53152 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53153 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53156 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53159 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53160 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53161 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53162 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53163 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53164 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53165 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53166 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53167 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53168 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53169 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53170 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53171 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53172 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53173 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53174 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53175 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53176 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53177 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53178 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53179 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53180 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53182 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53183 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53184 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53185 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53186 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53187 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53189 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53191 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53192 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53193 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53194 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53195 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53197 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53198 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53199 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53200 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53202 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53203 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53204 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53205 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53206 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53207 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53208 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53209 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53210 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53211 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53213 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53216 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53217 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53218 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53220 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53222 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53224 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53226 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53227 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53228 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53229 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53231 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53235 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53237 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53238 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53242 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53243 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53244 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53245 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53246 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53247 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53248 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53249 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53250 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53251 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53252 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53253 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53254 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53255 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53256 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53258 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53259 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53262 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53263 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53268 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53269 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53272 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53273 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53274 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53275 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53278 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53279 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53280 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53282 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53284 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53285 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53286 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53288 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53290 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53292 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53295 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53296 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53297 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53298 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53299 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53300 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53301 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53307 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53308 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53309 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53310 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53311 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53313 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53314 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53316 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53318 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53319 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53320 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53322 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53323 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53324 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53325 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53326 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53327 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53328 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53333 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53335 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53338 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53339 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53340 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53341 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53344 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53345 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53346 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53347 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53348 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53349 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53350 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53354 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53360 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53361 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53362 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53363 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53365 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53366 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53368 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53371 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53373 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53374 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53375 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53383 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53384 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53388 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53390 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53396 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53398 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53399 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53401 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53402 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53403 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53404 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53405 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53407 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53410 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53411 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53412 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53415 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53416 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53417 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53418 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53421 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53423 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53424 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53425 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53426 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53427 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53432 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53433 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53434 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53436 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53437 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53438 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53440 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53442 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53443 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53444 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53445 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53446 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53447 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53448 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53450 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53457 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53464 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53467 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53469 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53471 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53472 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53474 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53475 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53476 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53489 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53491 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53493 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53494 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53496 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53498 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53499 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53501 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53502 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53503 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53506 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53507 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53512 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53513 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53516 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53518 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53526 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53527 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53529 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53531 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53532 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53533 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53535 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53536 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53539 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53540 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53542 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53543 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53544 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53545 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53548 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53549 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53551 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53553 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53555 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53556 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53558 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53559 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53562 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53564 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53566 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53568 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53571 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53573 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53574 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53575 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53577 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53578 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53579 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53580 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53581 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53584 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53586 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53587 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53591 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53592 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53595 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53596 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53598 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53601 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53602 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53604 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53606 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53607 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53608 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53609 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53610 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53613 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53614 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53615 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53616 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53618 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53619 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53624 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53625 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53626 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53627 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53628 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53630 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53632 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53634 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53635 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53636 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53637 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53639 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53642 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53643 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53644 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53646 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53647 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53648 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53662 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53663 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53664 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53665 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53666 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53667 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53673 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53674 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53678 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53679 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53681 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53682 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53684 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53686 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53687 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53689 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53690 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53691 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53697 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53698 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53699 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53700 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53701 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53702 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53709 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53711 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53712 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53713 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53714 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53715 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53716 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53717 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53718 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53722 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53723 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53724 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53725 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53726 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53727 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53728 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53730 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53731 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53732 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53738 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53739 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53740 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53742 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53743 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53744 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53750 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53751 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53752 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53753 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53754 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53758 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53759 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53764 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53765 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53767 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53768 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53773 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53775 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53776 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53777 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53778 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53779 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53784 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53785 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53794 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53795 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53796 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53797 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53800 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53802 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53803 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53804 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53805 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53807 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53812 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53813 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53814 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53815 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53816 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53817 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53818 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53819 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53820 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53821 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53822 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53824 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53825 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53826 { NULL, NULL, 0, NULL }
53827 };
53828
53829
53830 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53831
53832 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53833 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53834 }
53835 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53836 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53837 }
53838 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53839 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53840 }
53841 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53842 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53843 }
53844 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53845 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53846 }
53847 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53848 return (void *)((wxSizer *) ((wxGridSizer *) x));
53849 }
53850 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53851 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53852 }
53853 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53854 return (void *)((wxSizer *) ((wxPySizer *) x));
53855 }
53856 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53857 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53858 }
53859 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53860 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53861 }
53862 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53863 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53864 }
53865 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53866 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53867 }
53868 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53869 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53870 }
53871 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53872 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53873 }
53874 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53875 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53876 }
53877 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53878 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53879 }
53880 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53881 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53882 }
53883 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53884 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53885 }
53886 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53887 return (void *)((wxEvent *) ((wxPyEvent *) x));
53888 }
53889 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53890 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53891 }
53892 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53893 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53894 }
53895 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53896 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53897 }
53898 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53899 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53900 }
53901 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53902 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53903 }
53904 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53905 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53906 }
53907 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53908 return (void *)((wxEvent *) ((wxActivateEvent *) x));
53909 }
53910 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
53911 return (void *)((wxEvent *) ((wxSizeEvent *) x));
53912 }
53913 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
53914 return (void *)((wxEvent *) ((wxMoveEvent *) x));
53915 }
53916 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
53917 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
53918 }
53919 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
53920 return (void *)((wxEvent *) ((wxPaintEvent *) x));
53921 }
53922 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
53923 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
53924 }
53925 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
53926 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
53927 }
53928 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
53929 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
53930 }
53931 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
53932 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
53933 }
53934 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
53935 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53936 }
53937 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
53938 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
53939 }
53940 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
53941 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
53942 }
53943 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
53944 return (void *)((wxEvent *) ((wxFocusEvent *) x));
53945 }
53946 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
53947 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
53948 }
53949 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
53950 return (void *)((wxEvent *) ((wxShowEvent *) x));
53951 }
53952 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
53953 return (void *)((wxEvent *) ((wxCommandEvent *) x));
53954 }
53955 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
53956 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
53957 }
53958 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
53959 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
53960 }
53961 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
53962 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
53963 }
53964 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
53965 return (void *)((wxEvent *) ((wxKeyEvent *) x));
53966 }
53967 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
53968 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
53969 }
53970 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
53971 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
53972 }
53973 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
53974 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
53975 }
53976 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
53977 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
53978 }
53979 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
53980 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
53981 }
53982 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
53983 return (void *)((wxControl *) ((wxControlWithItems *) x));
53984 }
53985 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
53986 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
53987 }
53988 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
53989 return (void *)((wxEvtHandler *) ((wxWindow *) x));
53990 }
53991 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
53992 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
53993 }
53994 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
53995 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
53996 }
53997 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
53998 return (void *)((wxEvtHandler *) ((wxValidator *) x));
53999 }
54000 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54001 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54002 }
54003 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54004 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54005 }
54006 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54007 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54008 }
54009 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54010 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54011 }
54012 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54013 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54014 }
54015 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54016 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54017 }
54018 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54019 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54020 }
54021 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54022 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54023 }
54024 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54025 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54026 }
54027 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54028 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54029 }
54030 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54031 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54032 }
54033 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54034 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54035 }
54036 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54037 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54038 }
54039 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54040 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54041 }
54042 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54043 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54044 }
54045 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54046 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54047 }
54048 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54049 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54050 }
54051 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54052 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54053 }
54054 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54055 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54056 }
54057 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54058 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54059 }
54060 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54061 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54062 }
54063 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54064 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54065 }
54066 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54067 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54068 }
54069 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54070 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54071 }
54072 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54073 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54074 }
54075 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54076 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54077 }
54078 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54079 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54080 }
54081 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54082 return (void *)((wxObject *) ((wxSizerItem *) x));
54083 }
54084 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54085 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54086 }
54087 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54088 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54089 }
54090 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54091 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54092 }
54093 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54094 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54095 }
54096 static void *_p_wxSizerTo_p_wxObject(void *x) {
54097 return (void *)((wxObject *) ((wxSizer *) x));
54098 }
54099 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54100 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54101 }
54102 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54103 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54104 }
54105 static void *_p_wxEventTo_p_wxObject(void *x) {
54106 return (void *)((wxObject *) ((wxEvent *) x));
54107 }
54108 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54109 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54110 }
54111 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54112 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54113 }
54114 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54115 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54116 }
54117 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54118 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54119 }
54120 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54121 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54122 }
54123 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54124 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54125 }
54126 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54127 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54128 }
54129 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54130 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54131 }
54132 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54133 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54134 }
54135 static void *_p_wxControlTo_p_wxObject(void *x) {
54136 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54137 }
54138 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54139 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54140 }
54141 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54142 return (void *)((wxObject *) ((wxFSFile *) x));
54143 }
54144 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54145 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54146 }
54147 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54148 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54149 }
54150 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54151 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54152 }
54153 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54154 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54155 }
54156 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54157 return (void *)((wxObject *) ((wxMenuItem *) x));
54158 }
54159 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54160 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54161 }
54162 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54163 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54164 }
54165 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54166 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54167 }
54168 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54169 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54170 }
54171 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54172 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54173 }
54174 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54175 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54176 }
54177 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54178 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54179 }
54180 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54181 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54182 }
54183 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54184 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54185 }
54186 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54187 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54188 }
54189 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54190 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54191 }
54192 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54193 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54194 }
54195 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54196 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54197 }
54198 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54199 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54200 }
54201 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54202 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54203 }
54204 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54205 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54206 }
54207 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54208 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54209 }
54210 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54211 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54212 }
54213 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54214 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54215 }
54216 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54217 return (void *)((wxObject *) ((wxImageHandler *) x));
54218 }
54219 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54220 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54221 }
54222 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54223 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54224 }
54225 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54226 return (void *)((wxObject *) ((wxEvtHandler *) x));
54227 }
54228 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54229 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54230 }
54231 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54232 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54233 }
54234 static void *_p_wxImageTo_p_wxObject(void *x) {
54235 return (void *)((wxObject *) ((wxImage *) x));
54236 }
54237 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54238 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54239 }
54240 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54241 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54242 }
54243 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54244 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54245 }
54246 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54247 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54248 }
54249 static void *_p_wxWindowTo_p_wxObject(void *x) {
54250 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54251 }
54252 static void *_p_wxMenuTo_p_wxObject(void *x) {
54253 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54254 }
54255 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54256 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54257 }
54258 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54259 return (void *)((wxObject *) ((wxFileSystem *) x));
54260 }
54261 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54262 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54263 }
54264 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54265 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54266 }
54267 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54268 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54269 }
54270 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54271 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54272 }
54273 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54274 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54275 }
54276 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54277 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54278 }
54279 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54280 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54281 }
54282 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54283 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54284 }
54285 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54286 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54287 }
54288 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54289 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54290 }
54291 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54292 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54293 }
54294 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54295 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54296 }
54297 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54298 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54299 }
54300 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54301 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54302 }
54303 static void *_p_wxControlTo_p_wxWindow(void *x) {
54304 return (void *)((wxWindow *) ((wxControl *) x));
54305 }
54306 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54307 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54308 }
54309 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54310 return (void *)((wxWindow *) ((wxMenuBar *) x));
54311 }
54312 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54313 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54314 }
54315 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54316 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54317 }
54318 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54319 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54320 }
54321 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54322 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54323 }
54324 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54325 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54326 }
54327 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54328 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54329 }
54330 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54331 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54332 }
54333 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54334 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54335 }
54336 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54337 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54338 }
54339 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54340 return (void *)((wxValidator *) ((wxPyValidator *) x));
54341 }
54342 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54343 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54344 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};
54345 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54346 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54347 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54348 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54349 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54350 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54351 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54352 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54353 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54354 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54355 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54356 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54357 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54358 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54359 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54360 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54361 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54362 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54363 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54364 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54365 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54366 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54367 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54368 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54369 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54370 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54371 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54372 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54373 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54374 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54375 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54376 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54377 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54378 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54379 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54380 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54381 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54382 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54383 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54384 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54385 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54386 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54387 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54388 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54389 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54390 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54391 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54392 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54393 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54394 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54395 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54396 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54397 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54398 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54399 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54400 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54401 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54402 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54403 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54404 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54405 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54406 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54407 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54408 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54409 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54410 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54411 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54412 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54413 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54414 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54415 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54416 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54417 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54418 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54419 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54420 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54421 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54422 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54423 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54424 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54425 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54426 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54427 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54428 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54429 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54430 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54431 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54432 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54433 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54434 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54435 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54436 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54437 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54438 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54439 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54440 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54441 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54442 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54443 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54444 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54445 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54446 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54447 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54448 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54449 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54450 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54451 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54452 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54453 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54454 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54455 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54456 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54457 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54458 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54459 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54460 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54461 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54462 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54463 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54464 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54465 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54466 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54467 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54468 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54469 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54470 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54471
54472 static swig_type_info *swig_type_initial[] = {
54473 &_swigt__p_buffer,
54474 &_swigt__p_char,
54475 &_swigt__p_form_ops_t,
54476 &_swigt__p_int,
54477 &_swigt__p_long,
54478 &_swigt__p_unsigned_char,
54479 &_swigt__p_unsigned_int,
54480 &_swigt__p_unsigned_long,
54481 &_swigt__p_wxANIHandler,
54482 &_swigt__p_wxAcceleratorEntry,
54483 &_swigt__p_wxAcceleratorTable,
54484 &_swigt__p_wxActivateEvent,
54485 &_swigt__p_wxAppTraits,
54486 &_swigt__p_wxArrayString,
54487 &_swigt__p_wxBMPHandler,
54488 &_swigt__p_wxBitmap,
54489 &_swigt__p_wxBoxSizer,
54490 &_swigt__p_wxButton,
54491 &_swigt__p_wxCURHandler,
54492 &_swigt__p_wxCaret,
54493 &_swigt__p_wxChildFocusEvent,
54494 &_swigt__p_wxCloseEvent,
54495 &_swigt__p_wxColour,
54496 &_swigt__p_wxCommandEvent,
54497 &_swigt__p_wxContextMenuEvent,
54498 &_swigt__p_wxControl,
54499 &_swigt__p_wxControlWithItems,
54500 &_swigt__p_wxCursor,
54501 &_swigt__p_wxDC,
54502 &_swigt__p_wxDateEvent,
54503 &_swigt__p_wxDateTime,
54504 &_swigt__p_wxDisplayChangedEvent,
54505 &_swigt__p_wxDropFilesEvent,
54506 &_swigt__p_wxDuplexMode,
54507 &_swigt__p_wxEraseEvent,
54508 &_swigt__p_wxEvent,
54509 &_swigt__p_wxEventLoop,
54510 &_swigt__p_wxEventLoopActivator,
54511 &_swigt__p_wxEvtHandler,
54512 &_swigt__p_wxFSFile,
54513 &_swigt__p_wxFileSystem,
54514 &_swigt__p_wxFileSystemHandler,
54515 &_swigt__p_wxFlexGridSizer,
54516 &_swigt__p_wxFocusEvent,
54517 &_swigt__p_wxFont,
54518 &_swigt__p_wxFrame,
54519 &_swigt__p_wxGBPosition,
54520 &_swigt__p_wxGBSizerItem,
54521 &_swigt__p_wxGBSpan,
54522 &_swigt__p_wxGIFHandler,
54523 &_swigt__p_wxGridBagSizer,
54524 &_swigt__p_wxGridSizer,
54525 &_swigt__p_wxICOHandler,
54526 &_swigt__p_wxIconizeEvent,
54527 &_swigt__p_wxIdleEvent,
54528 &_swigt__p_wxImage,
54529 &_swigt__p_wxImageHandler,
54530 &_swigt__p_wxImageHistogram,
54531 &_swigt__p_wxImage_HSVValue,
54532 &_swigt__p_wxImage_RGBValue,
54533 &_swigt__p_wxIndividualLayoutConstraint,
54534 &_swigt__p_wxInitDialogEvent,
54535 &_swigt__p_wxInputStream,
54536 &_swigt__p_wxInternetFSHandler,
54537 &_swigt__p_wxItemContainer,
54538 &_swigt__p_wxJPEGHandler,
54539 &_swigt__p_wxKeyEvent,
54540 &_swigt__p_wxLayoutConstraints,
54541 &_swigt__p_wxMaximizeEvent,
54542 &_swigt__p_wxMemoryFSHandler,
54543 &_swigt__p_wxMenu,
54544 &_swigt__p_wxMenuBar,
54545 &_swigt__p_wxMenuBarBase,
54546 &_swigt__p_wxMenuEvent,
54547 &_swigt__p_wxMenuItem,
54548 &_swigt__p_wxMouseCaptureChangedEvent,
54549 &_swigt__p_wxMouseEvent,
54550 &_swigt__p_wxMoveEvent,
54551 &_swigt__p_wxNavigationKeyEvent,
54552 &_swigt__p_wxNcPaintEvent,
54553 &_swigt__p_wxNotifyEvent,
54554 &_swigt__p_wxObject,
54555 &_swigt__p_wxOutputStream,
54556 &_swigt__p_wxPCXHandler,
54557 &_swigt__p_wxPNGHandler,
54558 &_swigt__p_wxPNMHandler,
54559 &_swigt__p_wxPaintEvent,
54560 &_swigt__p_wxPaletteChangedEvent,
54561 &_swigt__p_wxPaperSize,
54562 &_swigt__p_wxPoint,
54563 &_swigt__p_wxPoint2D,
54564 &_swigt__p_wxPropagateOnce,
54565 &_swigt__p_wxPropagationDisabler,
54566 &_swigt__p_wxPyApp,
54567 &_swigt__p_wxPyCommandEvent,
54568 &_swigt__p_wxPyDropTarget,
54569 &_swigt__p_wxPyEvent,
54570 &_swigt__p_wxPyFileSystemHandler,
54571 &_swigt__p_wxPyImageHandler,
54572 &_swigt__p_wxPyInputStream,
54573 &_swigt__p_wxPySizer,
54574 &_swigt__p_wxPyValidator,
54575 &_swigt__p_wxQuantize,
54576 &_swigt__p_wxQueryNewPaletteEvent,
54577 &_swigt__p_wxRealPoint,
54578 &_swigt__p_wxRect,
54579 &_swigt__p_wxRegion,
54580 &_swigt__p_wxScrollEvent,
54581 &_swigt__p_wxScrollWinEvent,
54582 &_swigt__p_wxSetCursorEvent,
54583 &_swigt__p_wxShowEvent,
54584 &_swigt__p_wxSize,
54585 &_swigt__p_wxSizeEvent,
54586 &_swigt__p_wxSizer,
54587 &_swigt__p_wxSizerItem,
54588 &_swigt__p_wxStaticBox,
54589 &_swigt__p_wxStaticBoxSizer,
54590 &_swigt__p_wxStdDialogButtonSizer,
54591 &_swigt__p_wxSysColourChangedEvent,
54592 &_swigt__p_wxTIFFHandler,
54593 &_swigt__p_wxToolTip,
54594 &_swigt__p_wxUpdateUIEvent,
54595 &_swigt__p_wxValidator,
54596 &_swigt__p_wxVisualAttributes,
54597 &_swigt__p_wxWindow,
54598 &_swigt__p_wxWindowCreateEvent,
54599 &_swigt__p_wxWindowDestroyEvent,
54600 &_swigt__p_wxXPMHandler,
54601 &_swigt__p_wxZipFSHandler,
54602 };
54603
54604 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54605 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54606 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54607 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54608 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54609 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54610 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54611 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54612 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54613 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54614 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54615 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54616 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54617 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54618 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}};
54619 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54620 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}};
54621 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54622 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}};
54623 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54624 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54625 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54626 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54627 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}};
54628 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54629 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}};
54630 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54631 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54632 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54633 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54634 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54635 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54636 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54637 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54638 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54639 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}};
54640 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54641 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54642 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}};
54643 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54644 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54645 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}};
54646 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}};
54647 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54648 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54649 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54650 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54651 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54652 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54653 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54654 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54655 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}};
54656 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}};
54657 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54658 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54659 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54660 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}};
54661 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54662 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54663 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54664 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54665 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54666 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54667 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54668 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}};
54669 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54670 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54671 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54672 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54673 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54674 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54675 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54676 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54677 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54678 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54679 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54680 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54681 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54682 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54683 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54684 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54685 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}};
54686 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54687 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54688 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54689 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54690 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54691 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54692 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54693 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54694 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54695 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54696 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54697 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54698 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54699 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54700 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54701 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54702 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54703 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54704 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54705 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54706 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54707 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54708 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54709 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54710 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54711 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54712 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54713 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54714 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54715 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54716 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54717 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}};
54718 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}};
54719 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54720 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54721 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54722 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54723 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54724 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54725 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54726 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}};
54727 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54728 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}};
54729 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54730 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54731 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54732 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54733
54734 static swig_cast_info *swig_cast_initial[] = {
54735 _swigc__p_buffer,
54736 _swigc__p_char,
54737 _swigc__p_form_ops_t,
54738 _swigc__p_int,
54739 _swigc__p_long,
54740 _swigc__p_unsigned_char,
54741 _swigc__p_unsigned_int,
54742 _swigc__p_unsigned_long,
54743 _swigc__p_wxANIHandler,
54744 _swigc__p_wxAcceleratorEntry,
54745 _swigc__p_wxAcceleratorTable,
54746 _swigc__p_wxActivateEvent,
54747 _swigc__p_wxAppTraits,
54748 _swigc__p_wxArrayString,
54749 _swigc__p_wxBMPHandler,
54750 _swigc__p_wxBitmap,
54751 _swigc__p_wxBoxSizer,
54752 _swigc__p_wxButton,
54753 _swigc__p_wxCURHandler,
54754 _swigc__p_wxCaret,
54755 _swigc__p_wxChildFocusEvent,
54756 _swigc__p_wxCloseEvent,
54757 _swigc__p_wxColour,
54758 _swigc__p_wxCommandEvent,
54759 _swigc__p_wxContextMenuEvent,
54760 _swigc__p_wxControl,
54761 _swigc__p_wxControlWithItems,
54762 _swigc__p_wxCursor,
54763 _swigc__p_wxDC,
54764 _swigc__p_wxDateEvent,
54765 _swigc__p_wxDateTime,
54766 _swigc__p_wxDisplayChangedEvent,
54767 _swigc__p_wxDropFilesEvent,
54768 _swigc__p_wxDuplexMode,
54769 _swigc__p_wxEraseEvent,
54770 _swigc__p_wxEvent,
54771 _swigc__p_wxEventLoop,
54772 _swigc__p_wxEventLoopActivator,
54773 _swigc__p_wxEvtHandler,
54774 _swigc__p_wxFSFile,
54775 _swigc__p_wxFileSystem,
54776 _swigc__p_wxFileSystemHandler,
54777 _swigc__p_wxFlexGridSizer,
54778 _swigc__p_wxFocusEvent,
54779 _swigc__p_wxFont,
54780 _swigc__p_wxFrame,
54781 _swigc__p_wxGBPosition,
54782 _swigc__p_wxGBSizerItem,
54783 _swigc__p_wxGBSpan,
54784 _swigc__p_wxGIFHandler,
54785 _swigc__p_wxGridBagSizer,
54786 _swigc__p_wxGridSizer,
54787 _swigc__p_wxICOHandler,
54788 _swigc__p_wxIconizeEvent,
54789 _swigc__p_wxIdleEvent,
54790 _swigc__p_wxImage,
54791 _swigc__p_wxImageHandler,
54792 _swigc__p_wxImageHistogram,
54793 _swigc__p_wxImage_HSVValue,
54794 _swigc__p_wxImage_RGBValue,
54795 _swigc__p_wxIndividualLayoutConstraint,
54796 _swigc__p_wxInitDialogEvent,
54797 _swigc__p_wxInputStream,
54798 _swigc__p_wxInternetFSHandler,
54799 _swigc__p_wxItemContainer,
54800 _swigc__p_wxJPEGHandler,
54801 _swigc__p_wxKeyEvent,
54802 _swigc__p_wxLayoutConstraints,
54803 _swigc__p_wxMaximizeEvent,
54804 _swigc__p_wxMemoryFSHandler,
54805 _swigc__p_wxMenu,
54806 _swigc__p_wxMenuBar,
54807 _swigc__p_wxMenuBarBase,
54808 _swigc__p_wxMenuEvent,
54809 _swigc__p_wxMenuItem,
54810 _swigc__p_wxMouseCaptureChangedEvent,
54811 _swigc__p_wxMouseEvent,
54812 _swigc__p_wxMoveEvent,
54813 _swigc__p_wxNavigationKeyEvent,
54814 _swigc__p_wxNcPaintEvent,
54815 _swigc__p_wxNotifyEvent,
54816 _swigc__p_wxObject,
54817 _swigc__p_wxOutputStream,
54818 _swigc__p_wxPCXHandler,
54819 _swigc__p_wxPNGHandler,
54820 _swigc__p_wxPNMHandler,
54821 _swigc__p_wxPaintEvent,
54822 _swigc__p_wxPaletteChangedEvent,
54823 _swigc__p_wxPaperSize,
54824 _swigc__p_wxPoint,
54825 _swigc__p_wxPoint2D,
54826 _swigc__p_wxPropagateOnce,
54827 _swigc__p_wxPropagationDisabler,
54828 _swigc__p_wxPyApp,
54829 _swigc__p_wxPyCommandEvent,
54830 _swigc__p_wxPyDropTarget,
54831 _swigc__p_wxPyEvent,
54832 _swigc__p_wxPyFileSystemHandler,
54833 _swigc__p_wxPyImageHandler,
54834 _swigc__p_wxPyInputStream,
54835 _swigc__p_wxPySizer,
54836 _swigc__p_wxPyValidator,
54837 _swigc__p_wxQuantize,
54838 _swigc__p_wxQueryNewPaletteEvent,
54839 _swigc__p_wxRealPoint,
54840 _swigc__p_wxRect,
54841 _swigc__p_wxRegion,
54842 _swigc__p_wxScrollEvent,
54843 _swigc__p_wxScrollWinEvent,
54844 _swigc__p_wxSetCursorEvent,
54845 _swigc__p_wxShowEvent,
54846 _swigc__p_wxSize,
54847 _swigc__p_wxSizeEvent,
54848 _swigc__p_wxSizer,
54849 _swigc__p_wxSizerItem,
54850 _swigc__p_wxStaticBox,
54851 _swigc__p_wxStaticBoxSizer,
54852 _swigc__p_wxStdDialogButtonSizer,
54853 _swigc__p_wxSysColourChangedEvent,
54854 _swigc__p_wxTIFFHandler,
54855 _swigc__p_wxToolTip,
54856 _swigc__p_wxUpdateUIEvent,
54857 _swigc__p_wxValidator,
54858 _swigc__p_wxVisualAttributes,
54859 _swigc__p_wxWindow,
54860 _swigc__p_wxWindowCreateEvent,
54861 _swigc__p_wxWindowDestroyEvent,
54862 _swigc__p_wxXPMHandler,
54863 _swigc__p_wxZipFSHandler,
54864 };
54865
54866
54867 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54868
54869 static swig_const_info swig_const_table[] = {
54870 {0, 0, 0, 0.0, 0, 0}};
54871
54872 #ifdef __cplusplus
54873 }
54874 #endif
54875 /* -----------------------------------------------------------------------------
54876 * Type initialization:
54877 * This problem is tough by the requirement that no dynamic
54878 * memory is used. Also, since swig_type_info structures store pointers to
54879 * swig_cast_info structures and swig_cast_info structures store pointers back
54880 * to swig_type_info structures, we need some lookup code at initialization.
54881 * The idea is that swig generates all the structures that are needed.
54882 * The runtime then collects these partially filled structures.
54883 * The SWIG_InitializeModule function takes these initial arrays out of
54884 * swig_module, and does all the lookup, filling in the swig_module.types
54885 * array with the correct data and linking the correct swig_cast_info
54886 * structures together.
54887 *
54888 * The generated swig_type_info structures are assigned staticly to an initial
54889 * array. We just loop though that array, and handle each type individually.
54890 * First we lookup if this type has been already loaded, and if so, use the
54891 * loaded structure instead of the generated one. Then we have to fill in the
54892 * cast linked list. The cast data is initially stored in something like a
54893 * two-dimensional array. Each row corresponds to a type (there are the same
54894 * number of rows as there are in the swig_type_initial array). Each entry in
54895 * a column is one of the swig_cast_info structures for that type.
54896 * The cast_initial array is actually an array of arrays, because each row has
54897 * a variable number of columns. So to actually build the cast linked list,
54898 * we find the array of casts associated with the type, and loop through it
54899 * adding the casts to the list. The one last trick we need to do is making
54900 * sure the type pointer in the swig_cast_info struct is correct.
54901 *
54902 * First off, we lookup the cast->type name to see if it is already loaded.
54903 * There are three cases to handle:
54904 * 1) If the cast->type has already been loaded AND the type we are adding
54905 * casting info to has not been loaded (it is in this module), THEN we
54906 * replace the cast->type pointer with the type pointer that has already
54907 * been loaded.
54908 * 2) If BOTH types (the one we are adding casting info to, and the
54909 * cast->type) are loaded, THEN the cast info has already been loaded by
54910 * the previous module so we just ignore it.
54911 * 3) Finally, if cast->type has not already been loaded, then we add that
54912 * swig_cast_info to the linked list (because the cast->type) pointer will
54913 * be correct.
54914 * ----------------------------------------------------------------------------- */
54915
54916 #ifdef __cplusplus
54917 extern "C" {
54918 #if 0
54919 } /* c-mode */
54920 #endif
54921 #endif
54922
54923 #if 0
54924 #define SWIGRUNTIME_DEBUG
54925 #endif
54926
54927 SWIGRUNTIME void
54928 SWIG_InitializeModule(void *clientdata) {
54929 size_t i;
54930 swig_module_info *module_head;
54931 static int init_run = 0;
54932
54933 clientdata = clientdata;
54934
54935 if (init_run) return;
54936 init_run = 1;
54937
54938 /* Initialize the swig_module */
54939 swig_module.type_initial = swig_type_initial;
54940 swig_module.cast_initial = swig_cast_initial;
54941
54942 /* Try and load any already created modules */
54943 module_head = SWIG_GetModule(clientdata);
54944 if (module_head) {
54945 swig_module.next = module_head->next;
54946 module_head->next = &swig_module;
54947 } else {
54948 /* This is the first module loaded */
54949 swig_module.next = &swig_module;
54950 SWIG_SetModule(clientdata, &swig_module);
54951 }
54952
54953 /* Now work on filling in swig_module.types */
54954 #ifdef SWIGRUNTIME_DEBUG
54955 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
54956 #endif
54957 for (i = 0; i < swig_module.size; ++i) {
54958 swig_type_info *type = 0;
54959 swig_type_info *ret;
54960 swig_cast_info *cast;
54961
54962 #ifdef SWIGRUNTIME_DEBUG
54963 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54964 #endif
54965
54966 /* if there is another module already loaded */
54967 if (swig_module.next != &swig_module) {
54968 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
54969 }
54970 if (type) {
54971 /* Overwrite clientdata field */
54972 #ifdef SWIGRUNTIME_DEBUG
54973 printf("SWIG_InitializeModule: found type %s\n", type->name);
54974 #endif
54975 if (swig_module.type_initial[i]->clientdata) {
54976 type->clientdata = swig_module.type_initial[i]->clientdata;
54977 #ifdef SWIGRUNTIME_DEBUG
54978 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
54979 #endif
54980 }
54981 } else {
54982 type = swig_module.type_initial[i];
54983 }
54984
54985 /* Insert casting types */
54986 cast = swig_module.cast_initial[i];
54987 while (cast->type) {
54988 /* Don't need to add information already in the list */
54989 ret = 0;
54990 #ifdef SWIGRUNTIME_DEBUG
54991 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
54992 #endif
54993 if (swig_module.next != &swig_module) {
54994 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
54995 #ifdef SWIGRUNTIME_DEBUG
54996 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
54997 #endif
54998 }
54999 if (ret) {
55000 if (type == swig_module.type_initial[i]) {
55001 #ifdef SWIGRUNTIME_DEBUG
55002 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55003 #endif
55004 cast->type = ret;
55005 ret = 0;
55006 } else {
55007 /* Check for casting already in the list */
55008 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55009 #ifdef SWIGRUNTIME_DEBUG
55010 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55011 #endif
55012 if (!ocast) ret = 0;
55013 }
55014 }
55015
55016 if (!ret) {
55017 #ifdef SWIGRUNTIME_DEBUG
55018 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55019 #endif
55020 if (type->cast) {
55021 type->cast->prev = cast;
55022 cast->next = type->cast;
55023 }
55024 type->cast = cast;
55025 }
55026 cast++;
55027 }
55028 /* Set entry in modules->types array equal to the type */
55029 swig_module.types[i] = type;
55030 }
55031 swig_module.types[i] = 0;
55032
55033 #ifdef SWIGRUNTIME_DEBUG
55034 printf("**** SWIG_InitializeModule: Cast List ******\n");
55035 for (i = 0; i < swig_module.size; ++i) {
55036 int j = 0;
55037 swig_cast_info *cast = swig_module.cast_initial[i];
55038 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55039 while (cast->type) {
55040 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55041 cast++;
55042 ++j;
55043 }
55044 printf("---- Total casts: %d\n",j);
55045 }
55046 printf("**** SWIG_InitializeModule: Cast List ******\n");
55047 #endif
55048 }
55049
55050 /* This function will propagate the clientdata field of type to
55051 * any new swig_type_info structures that have been added into the list
55052 * of equivalent types. It is like calling
55053 * SWIG_TypeClientData(type, clientdata) a second time.
55054 */
55055 SWIGRUNTIME void
55056 SWIG_PropagateClientData(void) {
55057 size_t i;
55058 swig_cast_info *equiv;
55059 static int init_run = 0;
55060
55061 if (init_run) return;
55062 init_run = 1;
55063
55064 for (i = 0; i < swig_module.size; i++) {
55065 if (swig_module.types[i]->clientdata) {
55066 equiv = swig_module.types[i]->cast;
55067 while (equiv) {
55068 if (!equiv->converter) {
55069 if (equiv->type && !equiv->type->clientdata)
55070 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55071 }
55072 equiv = equiv->next;
55073 }
55074 }
55075 }
55076 }
55077
55078 #ifdef __cplusplus
55079 #if 0
55080 {
55081 /* c-mode */
55082 #endif
55083 }
55084 #endif
55085
55086
55087
55088 #ifdef __cplusplus
55089 extern "C" {
55090 #endif
55091
55092 /* Python-specific SWIG API */
55093 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55094 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55095 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55096
55097 /* -----------------------------------------------------------------------------
55098 * global variable support code.
55099 * ----------------------------------------------------------------------------- */
55100
55101 typedef struct swig_globalvar {
55102 char *name; /* Name of global variable */
55103 PyObject *(*get_attr)(void); /* Return the current value */
55104 int (*set_attr)(PyObject *); /* Set the value */
55105 struct swig_globalvar *next;
55106 } swig_globalvar;
55107
55108 typedef struct swig_varlinkobject {
55109 PyObject_HEAD
55110 swig_globalvar *vars;
55111 } swig_varlinkobject;
55112
55113 SWIGINTERN PyObject *
55114 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55115 return PyString_FromString("<Swig global variables>");
55116 }
55117
55118 SWIGINTERN PyObject *
55119 swig_varlink_str(swig_varlinkobject *v) {
55120 PyObject *str = PyString_FromString("(");
55121 swig_globalvar *var;
55122 for (var = v->vars; var; var=var->next) {
55123 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55124 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55125 }
55126 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55127 return str;
55128 }
55129
55130 SWIGINTERN int
55131 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55132 PyObject *str = swig_varlink_str(v);
55133 fprintf(fp,"Swig global variables ");
55134 fprintf(fp,"%s\n", PyString_AsString(str));
55135 Py_DECREF(str);
55136 return 0;
55137 }
55138
55139 SWIGINTERN void
55140 swig_varlink_dealloc(swig_varlinkobject *v) {
55141 swig_globalvar *var = v->vars;
55142 while (var) {
55143 swig_globalvar *n = var->next;
55144 free(var->name);
55145 free(var);
55146 var = n;
55147 }
55148 }
55149
55150 SWIGINTERN PyObject *
55151 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55152 PyObject *res = NULL;
55153 swig_globalvar *var = v->vars;
55154 while (var) {
55155 if (strcmp(var->name,n) == 0) {
55156 res = (*var->get_attr)();
55157 break;
55158 }
55159 var = var->next;
55160 }
55161 if (res == NULL && !PyErr_Occurred()) {
55162 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55163 }
55164 return res;
55165 }
55166
55167 SWIGINTERN int
55168 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55169 int res = 1;
55170 swig_globalvar *var = v->vars;
55171 while (var) {
55172 if (strcmp(var->name,n) == 0) {
55173 res = (*var->set_attr)(p);
55174 break;
55175 }
55176 var = var->next;
55177 }
55178 if (res == 1 && !PyErr_Occurred()) {
55179 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55180 }
55181 return res;
55182 }
55183
55184 SWIGINTERN PyTypeObject*
55185 swig_varlink_type(void) {
55186 static char varlink__doc__[] = "Swig var link object";
55187 static PyTypeObject varlink_type;
55188 static int type_init = 0;
55189 if (!type_init) {
55190 const PyTypeObject tmp
55191 = {
55192 PyObject_HEAD_INIT(NULL)
55193 0, /* Number of items in variable part (ob_size) */
55194 (char *)"swigvarlink", /* Type name (tp_name) */
55195 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55196 0, /* Itemsize (tp_itemsize) */
55197 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55198 (printfunc) swig_varlink_print, /* Print (tp_print) */
55199 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55200 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55201 0, /* tp_compare */
55202 (reprfunc) swig_varlink_repr, /* tp_repr */
55203 0, /* tp_as_number */
55204 0, /* tp_as_sequence */
55205 0, /* tp_as_mapping */
55206 0, /* tp_hash */
55207 0, /* tp_call */
55208 (reprfunc)swig_varlink_str, /* tp_str */
55209 0, /* tp_getattro */
55210 0, /* tp_setattro */
55211 0, /* tp_as_buffer */
55212 0, /* tp_flags */
55213 varlink__doc__, /* tp_doc */
55214 0, /* tp_traverse */
55215 0, /* tp_clear */
55216 0, /* tp_richcompare */
55217 0, /* tp_weaklistoffset */
55218 #if PY_VERSION_HEX >= 0x02020000
55219 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55220 #endif
55221 #if PY_VERSION_HEX >= 0x02030000
55222 0, /* tp_del */
55223 #endif
55224 #ifdef COUNT_ALLOCS
55225 0,0,0,0 /* tp_alloc -> tp_next */
55226 #endif
55227 };
55228 varlink_type = tmp;
55229 varlink_type.ob_type = &PyType_Type;
55230 type_init = 1;
55231 }
55232 return &varlink_type;
55233 }
55234
55235 /* Create a variable linking object for use later */
55236 SWIGINTERN PyObject *
55237 SWIG_Python_newvarlink(void) {
55238 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55239 if (result) {
55240 result->vars = 0;
55241 }
55242 return ((PyObject*) result);
55243 }
55244
55245 SWIGINTERN void
55246 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55247 swig_varlinkobject *v = (swig_varlinkobject *) p;
55248 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55249 if (gv) {
55250 size_t size = strlen(name)+1;
55251 gv->name = (char *)malloc(size);
55252 if (gv->name) {
55253 strncpy(gv->name,name,size);
55254 gv->get_attr = get_attr;
55255 gv->set_attr = set_attr;
55256 gv->next = v->vars;
55257 }
55258 }
55259 v->vars = gv;
55260 }
55261
55262 SWIGINTERN PyObject *
55263 SWIG_globals() {
55264 static PyObject *_SWIG_globals = 0;
55265 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55266 return _SWIG_globals;
55267 }
55268
55269 /* -----------------------------------------------------------------------------
55270 * constants/methods manipulation
55271 * ----------------------------------------------------------------------------- */
55272
55273 /* Install Constants */
55274 SWIGINTERN void
55275 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55276 PyObject *obj = 0;
55277 size_t i;
55278 for (i = 0; constants[i].type; ++i) {
55279 switch(constants[i].type) {
55280 case SWIG_PY_POINTER:
55281 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55282 break;
55283 case SWIG_PY_BINARY:
55284 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55285 break;
55286 default:
55287 obj = 0;
55288 break;
55289 }
55290 if (obj) {
55291 PyDict_SetItemString(d, constants[i].name, obj);
55292 Py_DECREF(obj);
55293 }
55294 }
55295 }
55296
55297 /* -----------------------------------------------------------------------------*/
55298 /* Fix SwigMethods to carry the callback ptrs when needed */
55299 /* -----------------------------------------------------------------------------*/
55300
55301 SWIGINTERN void
55302 SWIG_Python_FixMethods(PyMethodDef *methods,
55303 swig_const_info *const_table,
55304 swig_type_info **types,
55305 swig_type_info **types_initial) {
55306 size_t i;
55307 for (i = 0; methods[i].ml_name; ++i) {
55308 char *c = methods[i].ml_doc;
55309 if (c && (c = strstr(c, "swig_ptr: "))) {
55310 int j;
55311 swig_const_info *ci = 0;
55312 char *name = c + 10;
55313 for (j = 0; const_table[j].type; ++j) {
55314 if (strncmp(const_table[j].name, name,
55315 strlen(const_table[j].name)) == 0) {
55316 ci = &(const_table[j]);
55317 break;
55318 }
55319 }
55320 if (ci) {
55321 size_t shift = (ci->ptype) - types;
55322 swig_type_info *ty = types_initial[shift];
55323 size_t ldoc = (c - methods[i].ml_doc);
55324 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55325 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55326 if (ndoc) {
55327 char *buff = ndoc;
55328 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55329 if (ptr) {
55330 strncpy(buff, methods[i].ml_doc, ldoc);
55331 buff += ldoc;
55332 strncpy(buff, "swig_ptr: ", 10);
55333 buff += 10;
55334 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55335 methods[i].ml_doc = ndoc;
55336 }
55337 }
55338 }
55339 }
55340 }
55341 }
55342
55343 #ifdef __cplusplus
55344 }
55345 #endif
55346
55347 /* -----------------------------------------------------------------------------*
55348 * Partial Init method
55349 * -----------------------------------------------------------------------------*/
55350
55351 #ifdef __cplusplus
55352 extern "C"
55353 #endif
55354 SWIGEXPORT void SWIG_init(void) {
55355 PyObject *m, *d;
55356
55357 /* Fix SwigMethods to carry the callback ptrs when needed */
55358 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55359
55360 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55361 d = PyModule_GetDict(m);
55362
55363 SWIG_InitializeModule(0);
55364 SWIG_InstallConstants(d,swig_const_table);
55365
55366
55367
55368 #ifndef wxPyUSE_EXPORT
55369 // Make our API structure a CObject so other modules can import it
55370 // from this module.
55371 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55372 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55373 Py_XDECREF(cobj);
55374 #endif
55375
55376 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55377 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55378 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55379 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55380 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55381 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55382 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55383 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55384 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55385 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55386 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55387 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55388 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55389 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55390 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55391 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55392 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55393 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55394 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55395 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55396 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55397 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55398 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55399 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55400 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55401 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55402 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55403 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55404 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55405 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55406 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55407 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55408 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55409 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55410 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55411 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55412 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55413 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55414 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55415 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55416 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55417 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55418 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55419 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55420 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55421 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55422 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55423 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55424 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55425 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55426 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55427 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55428 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55429 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55430 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55431 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55432 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55433 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55434 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55435 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55436 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55437 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55438 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55439 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55440 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55441 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55442 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55443 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55444 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55445 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55446 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55447 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55448 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55449 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55450 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55451 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55452 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55453 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55454 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55455 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55456 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55457 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55458 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55459 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55460 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55461 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55462 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55463 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55464 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55465 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55466 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55467 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55468 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55469 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55470 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55471 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55472 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55473 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55474 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55475 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55476 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55477 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55478 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55479 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55480 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55481 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55482 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55483 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55484 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55485 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55486 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55487 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55488 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55489 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55490 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55491 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55492 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55493 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55494 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55495 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55496 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55497 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55498 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55499 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55500 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55501 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55502 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55503 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55504 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55505 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55506 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55507 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55508 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55509 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55510 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55511 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55512 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55513 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55514 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55515 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55516 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55517 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55518 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55519 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55520 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55521 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55522 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55523 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55524 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55525 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55526 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55527 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55528 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55529 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55530 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55531 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55532 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55533 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55534 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55535 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55536 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55537 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55538 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55539 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55540 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55541 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55542 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55543 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55544 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55545 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55546 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55547 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55548 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55549 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55550 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55551 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55552 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55553 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55554 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55555 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55556 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55557 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55558 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55559 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55560 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55561 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55562 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55563 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55564 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55565 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55566 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55567 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55568 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55569 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55570 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55571 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55572 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55573 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55574 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55575 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55576 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55577 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55578 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55579 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55580 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55581 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55582 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55583 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55584 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55585 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55586 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55587 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55588 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55589 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55590 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55591 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55592 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55593 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55594 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55595 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55596 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55597 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55598 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55599 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55600 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55601 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55602 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55603 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55604 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55605 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55606 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55607 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55608 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55609 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55610 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55611 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55612 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55613 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55614 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55615 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55616 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55617 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55618 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55619 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55620 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55621 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55622 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55623 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55624 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55625 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55626 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55627 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55628 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55629 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55630 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55631 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55632 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55633 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55634 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55635 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55636 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55637 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55638 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55639 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55640 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55641 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55642 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55643 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55644 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55645 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55646 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55647 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55648 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55649 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55650 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55651 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55652 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55653 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55654 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55655 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55656 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55657 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55658 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55659 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55660 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55661 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55662 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55663 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55664 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55665 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55666 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55667 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55668 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55669 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55670 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55671 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55672 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55673 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55674 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55675 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55676 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55677 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55678 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55679 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55680 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55681 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55682 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55683 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55684 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55685 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55686 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55687 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55688 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55689 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55690 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55691 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55692 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55693 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55694 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55695 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55696 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55697 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55698 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55699 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55700 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55701 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55702 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55703 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55704 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55705 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55706 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55707 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55708 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55709 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55710 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55711 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55712 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55713 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55714 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55715 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55716 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55717 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55718 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55719 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55720 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55721 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55722 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55723 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55724 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55725 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55726 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55727 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55728 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55729 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55730 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55731 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55732 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55733 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55734 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55735 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55736 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55737 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55738 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55739 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55740 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55741 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55742 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55743 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55744 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55745 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55746 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55747 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55748 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55749 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55750 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55751 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55752 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55753 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55754 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55755 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55756 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55757 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55758 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55759 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55760 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55761 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55762 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55763 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55764 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55765 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55766 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55767 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55768 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55769 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55770 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55771 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55772 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55773 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55774 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55775 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55776 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55777 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55778 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55779 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55780 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55781 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55782 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55783 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55784 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55785 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55786 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55787 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55788 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55789 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55790 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55791 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55792 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55793 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55794 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55795 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55796 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55797 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55798 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55799 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55800 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55801 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55802 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55803 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55804 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55805 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55806 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55807 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55808 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55809 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55810 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55811 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55812 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55813 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55814 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55815 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55816 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55817 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55818 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55819 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55820 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55821 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55822 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55823 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55824 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55825 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55826 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55827 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55828 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55829 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55830 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55831 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55832 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55833 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55834 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55835 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55836 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55837 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55838 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55839 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55840 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55841 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55842 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55843 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55844 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55845 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55846 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55847 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55848 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55849 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55850 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55851 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55852 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55853 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55854 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55855 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55856 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55857 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55858 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55859 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55860 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55861 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55862 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55863 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55864 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55865 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55866 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55867 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55868 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55869 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55870 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55871 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55872 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55873 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55874 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55875 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55876 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55877 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55878 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55879 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55880 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55881 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55882 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55883 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55884 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55885 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55886 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55887 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55888 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55889 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55890 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55891 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55892 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55893 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55894 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55895 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55896 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55897 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55898 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55899 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55900 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55901 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55902 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55903 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55904 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55905 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55906 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
55907 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
55908 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
55909 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
55910 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
55911 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
55912 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
55913 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
55914 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
55915 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
55916 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
55917 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
55918 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
55919 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
55920 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
55921 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
55922 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
55923 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
55924 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
55925 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
55926 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
55927 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
55928 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
55929 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
55930 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
55931 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
55932 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
55933 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
55934 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
55935 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
55936 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
55937 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
55938 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
55939 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
55940 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
55941 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
55942 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
55943 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
55944 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
55945 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
55946 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
55947 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
55948 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
55949 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
55950 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
55951 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
55952 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
55953 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
55954 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
55955 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
55956 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
55957 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
55958 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
55959 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
55960 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
55961 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
55962 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
55963 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
55964 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
55965 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
55966 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
55967 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
55968 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
55969 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
55970 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
55971 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
55972 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
55973 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
55974 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
55975 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
55976 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
55977 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
55978 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
55979 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
55980 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
55981 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
55982 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
55983 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
55984 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
55985 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
55986 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
55987 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
55988 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
55989 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
55990 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
55991 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
55992 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
55993 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
55994 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
55995 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
55996 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
55997 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
55998 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
55999 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56000 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56001 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56002 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56003 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56004 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56005 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56006 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56007 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56008 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56009 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56010 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56011 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56012 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56013 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56014 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56015 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56016 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56017 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56018 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56019 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56020 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56021 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56022 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56023 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56024 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56025 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56026 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56027 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56028 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56029 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56030 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56031 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56032 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56033 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56034 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56035 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56036 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56037 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56038 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56039 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56040 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56041 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56042 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56043 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56044 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56045
56046 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56047
56048
56049 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56050
56051 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56052 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56053 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56054 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56055 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56056 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56057 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56058 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56059 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56060 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56061 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56062 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56063 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56064 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56065 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56066 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56067 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56068 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56069 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56070 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56071 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56072 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56073 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56074 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56075 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56076 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56077 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56078 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56079 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56080 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56081 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56082 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56083 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56084 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56085 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56086 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56087 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56088 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56089 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56090 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56091 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56092 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56093 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56094 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56095 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56096 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56097 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56098 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56099 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56100 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56101 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56102 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56103 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56104 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56105 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56106 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56107 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56108 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56109 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56110 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56111 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56112 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56113 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56114 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56115 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56116 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56117 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56118 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56119 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56120 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56121 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56122 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56123 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56124 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56125 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56126 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56127 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56128 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56129 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56130 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56131 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56132 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56133 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56134 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56135 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56136 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56137 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56138 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56139 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56140 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56141 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56142 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56143 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56144 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56145 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56146 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56147 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56148 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56149 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56150 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56151 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56152 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56153 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56154 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56155 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56156 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56157 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56158 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56159 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56160 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56161 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56162 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56163 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56164 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56165 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56166 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56167 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56168 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56169 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56170 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56171 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56172 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56173 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56174 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56175 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56176 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56177 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56178 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56179 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56180 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56181 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56182 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56183 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56184 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56185 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56186 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56187 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56188 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56189 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56190 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56191 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56192 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56193 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56194 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56195 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56196 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56197 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56198 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56199 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56200 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56201 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56202 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56203 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56204 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56205 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56206 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56207 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56208 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56209 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56210 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56211 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56212 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56213 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56214 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56215 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56216 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56217 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56218 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56219 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56220 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56221 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56222 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56223 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56224 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56225 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56226 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56227 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56228 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56229 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56230 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56231 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56232 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56233 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56234 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56235 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56236 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56237 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56238 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56239 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56240 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56241 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56242 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56243 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56244 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56245 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56246 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56247 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56248 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56249 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56250 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56251 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56252 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56253 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56254 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56255
56256 // Initialize threading, some globals and such
56257 __wxPyPreStart(d);
56258
56259
56260 // Although these are defined in __version__ they need to be here too so
56261 // that an assert can be done to ensure that the wxPython and the wxWindows
56262 // versions match.
56263 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56264 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56265 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56266
56267 }
56268
wxWidgets (Impactor)