]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:


c11de14c4a9e1dddcd96949aeaa4f0037405df41
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 // Pull the nested class out to the top level for SWIG's sake
3487 #define wxImage_RGBValue wxImage::RGBValue
3488 #define wxImage_HSVValue wxImage::HSVValue
3489
3490 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3491 if (width > 0 && height > 0)
3492 return new wxImage(width, height, clear);
3493 else
3494 return new wxImage;
3495 }
3496 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3497 return new wxImage(bitmap.ConvertToImage());
3498 }
3499 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3500 if (DATASIZE != width*height*3) {
3501 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3502 return NULL;
3503 }
3504
3505 // Copy the source data so the wxImage can clean it up later
3506 buffer copy = (buffer)malloc(DATASIZE);
3507 if (copy == NULL) {
3508 wxPyBLOCK_THREADS(PyErr_NoMemory());
3509 return NULL;
3510 }
3511 memcpy(copy, data, DATASIZE);
3512 return new wxImage(width, height, copy, false);
3513 }
3514 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3515 if (DATASIZE != width*height*3) {
3516 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3517 return NULL;
3518 }
3519 if (ALPHASIZE != width*height) {
3520 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3521 return NULL;
3522 }
3523
3524 // Copy the source data so the wxImage can clean it up later
3525 buffer dcopy = (buffer)malloc(DATASIZE);
3526 if (dcopy == NULL) {
3527 wxPyBLOCK_THREADS(PyErr_NoMemory());
3528 return NULL;
3529 }
3530 memcpy(dcopy, data, DATASIZE);
3531
3532 buffer acopy = (buffer)malloc(ALPHASIZE);
3533 if (acopy == NULL) {
3534 wxPyBLOCK_THREADS(PyErr_NoMemory());
3535 return NULL;
3536 }
3537 memcpy(acopy, alpha, ALPHASIZE);
3538
3539 return new wxImage(width, height, dcopy, acopy, false);
3540 }
3541 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3542 wxSize size(self->GetWidth(), self->GetHeight());
3543 return size;
3544 }
3545 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3546 buffer data = self->GetData();
3547 int len = self->GetWidth() * self->GetHeight() * 3;
3548 PyObject* rv;
3549 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3550 return rv;
3551 }
3552 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3553 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3554 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3555 return;
3556 }
3557 buffer copy = (buffer)malloc(DATASIZE);
3558 if (copy == NULL) {
3559 wxPyBLOCK_THREADS(PyErr_NoMemory());
3560 return;
3561 }
3562 memcpy(copy, data, DATASIZE);
3563 self->SetData(copy, false);
3564 // wxImage takes ownership of copy...
3565 }
3566 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3567 buffer data = self->GetData();
3568 int len = self->GetWidth() * self->GetHeight() * 3;
3569 PyObject* rv;
3570 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3571 return rv;
3572 }
3573 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3574 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3575 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3576 return;
3577 }
3578 self->SetData(data, true);
3579 }
3580 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3581 buffer data = self->GetAlpha();
3582 if (! data) {
3583 RETURN_NONE();
3584 } else {
3585 int len = self->GetWidth() * self->GetHeight();
3586 PyObject* rv;
3587 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3588 return rv;
3589 }
3590 }
3591 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3592 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3593 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3594 return;
3595 }
3596 buffer acopy = (buffer)malloc(ALPHASIZE);
3597 if (acopy == NULL) {
3598 wxPyBLOCK_THREADS(PyErr_NoMemory());
3599 return;
3600 }
3601 memcpy(acopy, alpha, ALPHASIZE);
3602 self->SetAlpha(acopy, false);
3603 // wxImage takes ownership of acopy...
3604 }
3605 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3606 buffer data = self->GetAlpha();
3607 int len = self->GetWidth() * self->GetHeight();
3608 PyObject* rv;
3609 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3610 return rv;
3611 }
3612 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3613 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3614 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3615 return;
3616 }
3617 self->SetAlpha(alpha, true);
3618 }
3619 SWIGINTERN PyObject *wxImage_GetHandlers(){
3620 wxList& list = wxImage::GetHandlers();
3621 return wxPy_ConvertList(&list);
3622 }
3623 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3624 wxBitmap bitmap(*self, depth);
3625 return bitmap;
3626 }
3627 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3628 wxImage mono = self->ConvertToMono( red, green, blue );
3629 wxBitmap bitmap( mono, 1 );
3630 return bitmap;
3631 }
3632
3633 wxImage* _ImageFromBuffer(int width, int height,
3634 buffer data, int DATASIZE,
3635 buffer alpha=NULL, int ALPHASIZE=0)
3636 {
3637 if (DATASIZE != width*height*3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return NULL;
3640 }
3641 if (alpha != NULL) {
3642 if (ALPHASIZE != width*height) {
3643 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3644 return NULL;
3645 }
3646 return new wxImage(width, height, data, alpha, true);
3647 }
3648 return new wxImage(width, height, data, true);
3649 }
3650
3651 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3652 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3653 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3655 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3659 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3660 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3661 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3662 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3663 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3664 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3665 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3666
3667 #include <wx/quantize.h>
3668
3669 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3670 return wxQuantize::Quantize(src, dest,
3671 //NULL, // palette
3672 desiredNoColours,
3673 NULL, // eightBitData
3674 flags);
3675 }
3676 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3677 if (PyCallable_Check(func)) {
3678 self->Connect(id, lastId, eventType,
3679 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3680 new wxPyCallback(func));
3681 }
3682 else if (func == Py_None) {
3683 self->Disconnect(id, lastId, eventType,
3684 (wxObjectEventFunction)
3685 &wxPyCallback::EventThunker);
3686 }
3687 else {
3688 wxPyBLOCK_THREADS(
3689 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3690 }
3691 }
3692 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3693 return self->Disconnect(id, lastId, eventType,
3694 (wxObjectEventFunction)
3695 &wxPyCallback::EventThunker);
3696 }
3697 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3698 if (_self && _self != Py_None) {
3699 self->SetClientObject(new wxPyOORClientData(_self, incref));
3700 }
3701 else {
3702 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3703 if (data) {
3704 self->SetClientObject(NULL); // This will delete it too
3705 }
3706 }
3707 }
3708
3709 #if ! wxUSE_HOTKEY
3710 #define wxEVT_HOTKEY -9999
3711 #endif
3712
3713 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3714 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3715 if (data) {
3716 Py_INCREF(data->m_obj);
3717 return data->m_obj;
3718 } else {
3719 Py_INCREF(Py_None);
3720 return Py_None;
3721 }
3722 }
3723 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3724 wxPyClientData* data = new wxPyClientData(clientData);
3725 self->SetClientObject(data);
3726 }
3727 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3728 #if wxUSE_UNICODE
3729 return self->GetUnicodeKey();
3730 #else
3731 return 0;
3732 #endif
3733 }
3734 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3735 #if wxUSE_UNICODE
3736 self->m_uniChar = uniChar;
3737 #endif
3738 }
3739
3740 SWIGINTERNINLINE PyObject *
3741 SWIG_From_unsigned_SS_int (unsigned int value)
3742 {
3743 return SWIG_From_unsigned_SS_long (value);
3744 }
3745
3746
3747 SWIGINTERN int
3748 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3749 {
3750 unsigned long v;
3751 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3752 if (SWIG_IsOK(res)) {
3753 if ((v > UINT_MAX)) {
3754 return SWIG_OverflowError;
3755 } else {
3756 if (val) *val = static_cast< unsigned int >(v);
3757 }
3758 }
3759 return res;
3760 }
3761
3762 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3763 self->m_size = size;
3764 }
3765 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3766 int count = self->GetNumberOfFiles();
3767 wxString* files = self->GetFiles();
3768 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3769 PyObject* list = PyList_New(count);
3770
3771 if (!list) {
3772 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3773 wxPyEndBlockThreads(blocked);
3774 return NULL;
3775 }
3776
3777 for (int i=0; i<count; i++) {
3778 PyList_SetItem(list, i, wx2PyString(files[i]));
3779 }
3780 wxPyEndBlockThreads(blocked);
3781 return list;
3782 }
3783
3784
3785 SWIGINTERN wxPyApp *new_wxPyApp(){
3786 wxPythonApp = new wxPyApp();
3787 return wxPythonApp;
3788 }
3789 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3790 return wxPyTestDisplayAvailable();
3791 }
3792
3793 void wxApp_CleanUp() {
3794 __wxPyCleanup();
3795 }
3796
3797
3798 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3799
3800
3801
3802
3803
3804 SWIGINTERNINLINE PyObject *
3805 SWIG_FromCharPtr(const char *cptr)
3806 {
3807 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3808 }
3809
3810
3811 #if 0 // #ifdef __WXMAC__
3812
3813 // A dummy class that raises an exception if used...
3814 class wxEventLoop
3815 {
3816 public:
3817 wxEventLoop() { wxPyRaiseNotImplemented(); }
3818 int Run() { return 0; }
3819 void Exit(int rc = 0) {}
3820 bool Pending() const { return false; }
3821 bool Dispatch() { return false; }
3822 bool IsRunning() const { return false; }
3823 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3824 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3825 };
3826
3827 #else
3828
3829 #include <wx/evtloop.h>
3830
3831 #endif
3832
3833
3834
3835 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3836 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3837 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3838 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3839 wxWindowList& list = self->GetChildren();
3840 return wxPy_ConvertList(&list);
3841 }
3842 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3843 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3844 #if wxUSE_HOTKEY
3845 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3846 #else
3847 return false;
3848 #endif
3849 }
3850 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3851
3852
3853
3854 return false;
3855
3856 }
3857 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3858 return wxPyGetWinHandle(self);
3859 }
3860 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3861 self->AssociateHandle((WXWidget)handle);
3862 }
3863
3864 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3865 return wxWindow::FindWindowById(id, parent);
3866 }
3867
3868 wxWindow* wxFindWindowByName( const wxString& name,
3869 const wxWindow *parent = NULL ) {
3870 return wxWindow::FindWindowByName(name, parent);
3871 }
3872
3873 wxWindow* wxFindWindowByLabel( const wxString& label,
3874 const wxWindow *parent = NULL ) {
3875 return wxWindow::FindWindowByLabel(label, parent);
3876 }
3877
3878
3879 #ifdef __WXMSW__
3880 #include <wx/msw/private.h> // to get wxGetWindowId
3881 #endif
3882
3883
3884 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3885 #ifdef __WXMSW__
3886 WXHWND hWnd = (WXHWND)_hWnd;
3887 long id = wxGetWindowId(hWnd);
3888 wxWindow* win = new wxWindow;
3889 if (parent)
3890 parent->AddChild(win);
3891 win->SetEventHandler(win);
3892 win->SetHWND(hWnd);
3893 win->SetId(id);
3894 win->SubclassWin(hWnd);
3895 win->AdoptAttributesFromHWND();
3896 win->SetupColours();
3897 return win;
3898 #else
3899 wxPyRaiseNotImplemented();
3900 return NULL;
3901 #endif
3902 }
3903
3904
3905 PyObject* GetTopLevelWindows() {
3906 return wxPy_ConvertList(&wxTopLevelWindows);
3907 }
3908
3909
3910 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3911 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3912 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3913
3914 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3915
3916
3917 SWIGINTERNINLINE int
3918 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3919 {
3920 unsigned long v;
3921 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3922 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3923 return res;
3924 }
3925
3926 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3927 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3928 wxMenuItemList& list = self->GetMenuItems();
3929 return wxPy_ConvertList(&list);
3930 }
3931 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3932 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3933 static const wxString wxPyControlNameStr(wxControlNameStr);
3934 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3935 if (clientData) {
3936 wxPyClientData* data = new wxPyClientData(clientData);
3937 return self->Append(item, data);
3938 } else
3939 return self->Append(item);
3940 }
3941 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3942 if (clientData) {
3943 wxPyClientData* data = new wxPyClientData(clientData);
3944 return self->Insert(item, pos, data);
3945 } else
3946 return self->Insert(item, pos);
3947 }
3948 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3949 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3950 if (data) {
3951 Py_INCREF(data->m_obj);
3952 return data->m_obj;
3953 } else {
3954 Py_INCREF(Py_None);
3955 return Py_None;
3956 }
3957 }
3958 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3959 wxPyClientData* data = new wxPyClientData(clientData);
3960 self->SetClientObject(n, data);
3961 }
3962
3963
3964 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3965 wxPyUserData* data = NULL;
3966 if ( userData ) {
3967 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3968 data = new wxPyUserData(userData);
3969 wxPyEndBlockThreads(blocked);
3970 }
3971 return new wxSizerItem(window, proportion, flag, border, data);
3972 }
3973 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3974 wxPyUserData* data = NULL;
3975 if ( userData ) {
3976 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3977 data = new wxPyUserData(userData);
3978 wxPyEndBlockThreads(blocked);
3979 }
3980 return new wxSizerItem(width, height, proportion, flag, border, data);
3981 }
3982 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3983 wxPyUserData* data = NULL;
3984 if ( userData ) {
3985 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3986 data = new wxPyUserData(userData);
3987 wxPyEndBlockThreads(blocked);
3988 }
3989 return new wxSizerItem(sizer, proportion, flag, border, data);
3990 }
3991
3992 SWIGINTERNINLINE PyObject *
3993 SWIG_From_float (float value)
3994 {
3995 return SWIG_From_double (value);
3996 }
3997
3998 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3999 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4000 if (data) {
4001 Py_INCREF(data->m_obj);
4002 return data->m_obj;
4003 } else {
4004 Py_INCREF(Py_None);
4005 return Py_None;
4006 }
4007 }
4008 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4009 wxPyUserData* data = NULL;
4010 if ( userData ) {
4011 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4012 data = new wxPyUserData(userData);
4013 wxPyEndBlockThreads(blocked);
4014 }
4015 self->SetUserData(data);
4016 }
4017
4018 // Figure out the type of the sizer item
4019
4020 struct wxPySizerItemInfo {
4021 wxPySizerItemInfo()
4022 : window(NULL), sizer(NULL), gotSize(false),
4023 size(wxDefaultSize), gotPos(false), pos(-1)
4024 {}
4025
4026 wxWindow* window;
4027 wxSizer* sizer;
4028 bool gotSize;
4029 wxSize size;
4030 bool gotPos;
4031 int pos;
4032 };
4033
4034 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4035
4036 wxPySizerItemInfo info;
4037 wxSize size;
4038 wxSize* sizePtr = &size;
4039
4040 // Find out what the type of the item is
4041 // try wxWindow
4042 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4043 PyErr_Clear();
4044 info.window = NULL;
4045
4046 // try wxSizer
4047 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4048 PyErr_Clear();
4049 info.sizer = NULL;
4050
4051 // try wxSize or (w,h)
4052 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4053 info.size = *sizePtr;
4054 info.gotSize = true;
4055 }
4056
4057 // or a single int
4058 if (checkIdx && PyInt_Check(item)) {
4059 info.pos = PyInt_AsLong(item);
4060 info.gotPos = true;
4061 }
4062 }
4063 }
4064
4065 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4066 // no expected type, figure out what kind of error message to generate
4067 if ( !checkSize && !checkIdx )
4068 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4069 else if ( checkSize && !checkIdx )
4070 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4071 else if ( !checkSize && checkIdx)
4072 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4073 else
4074 // can this one happen?
4075 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4076 }
4077
4078 return info;
4079 }
4080
4081 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4082 if (!self->GetClientObject())
4083 self->SetClientObject(new wxPyOORClientData(_self));
4084 }
4085 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4086
4087 wxPyUserData* data = NULL;
4088 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4089 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4090 if ( userData && (info.window || info.sizer || info.gotSize) )
4091 data = new wxPyUserData(userData);
4092 if ( info.sizer )
4093 PyObject_SetAttrString(item,"thisown",Py_False);
4094 wxPyEndBlockThreads(blocked);
4095
4096 // Now call the real Add method if a valid item type was found
4097 if ( info.window )
4098 return self->Add(info.window, proportion, flag, border, data);
4099 else if ( info.sizer )
4100 return self->Add(info.sizer, proportion, flag, border, data);
4101 else if (info.gotSize)
4102 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4103 proportion, flag, border, data);
4104 else
4105 return NULL;
4106 }
4107 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4108
4109 wxPyUserData* data = NULL;
4110 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4111 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4112 if ( userData && (info.window || info.sizer || info.gotSize) )
4113 data = new wxPyUserData(userData);
4114 if ( info.sizer )
4115 PyObject_SetAttrString(item,"thisown",Py_False);
4116 wxPyEndBlockThreads(blocked);
4117
4118 // Now call the real Insert method if a valid item type was found
4119 if ( info.window )
4120 return self->Insert(before, info.window, proportion, flag, border, data);
4121 else if ( info.sizer )
4122 return self->Insert(before, info.sizer, proportion, flag, border, data);
4123 else if (info.gotSize)
4124 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4125 proportion, flag, border, data);
4126 else
4127 return NULL;
4128 }
4129 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4130
4131 wxPyUserData* data = NULL;
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4134 if ( userData && (info.window || info.sizer || info.gotSize) )
4135 data = new wxPyUserData(userData);
4136 if ( info.sizer )
4137 PyObject_SetAttrString(item,"thisown",Py_False);
4138 wxPyEndBlockThreads(blocked);
4139
4140 // Now call the real Prepend method if a valid item type was found
4141 if ( info.window )
4142 return self->Prepend(info.window, proportion, flag, border, data);
4143 else if ( info.sizer )
4144 return self->Prepend(info.sizer, proportion, flag, border, data);
4145 else if (info.gotSize)
4146 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4147 proportion, flag, border, data);
4148 else
4149 return NULL;
4150 }
4151 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4152 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4153 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4154 wxPyEndBlockThreads(blocked);
4155 if ( info.window )
4156 return self->Remove(info.window);
4157 else if ( info.sizer )
4158 return self->Remove(info.sizer);
4159 else if ( info.gotPos )
4160 return self->Remove(info.pos);
4161 else
4162 return false;
4163 }
4164 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4165 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4166 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4167 wxPyEndBlockThreads(blocked);
4168 if ( info.window )
4169 return self->Detach(info.window);
4170 else if ( info.sizer )
4171 return self->Detach(info.sizer);
4172 else if ( info.gotPos )
4173 return self->Detach(info.pos);
4174 else
4175 return false;
4176 }
4177 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4179 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4180 wxPyEndBlockThreads(blocked);
4181 if ( info.window )
4182 return self->GetItem(info.window);
4183 else if ( info.sizer )
4184 return self->GetItem(info.sizer);
4185 else if ( info.gotPos )
4186 return self->GetItem(info.pos);
4187 else
4188 return NULL;
4189 }
4190 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4192 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4193 wxPyEndBlockThreads(blocked);
4194 if ( info.window )
4195 self->SetItemMinSize(info.window, size);
4196 else if ( info.sizer )
4197 self->SetItemMinSize(info.sizer, size);
4198 else if ( info.gotPos )
4199 self->SetItemMinSize(info.pos, size);
4200 }
4201 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4202 wxSizerItemList& list = self->GetChildren();
4203 return wxPy_ConvertList(&list);
4204 }
4205 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4206 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4207 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4208 wxPyEndBlockThreads(blocked);
4209 if ( info.window )
4210 return self->Show(info.window, show, recursive);
4211 else if ( info.sizer )
4212 return self->Show(info.sizer, show, recursive);
4213 else if ( info.gotPos )
4214 return self->Show(info.pos, show);
4215 else
4216 return false;
4217 }
4218 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4219 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4220 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4221 wxPyEndBlockThreads(blocked);
4222 if ( info.window )
4223 return self->IsShown(info.window);
4224 else if ( info.sizer )
4225 return self->IsShown(info.sizer);
4226 else if ( info.gotPos )
4227 return self->IsShown(info.pos);
4228 else
4229 return false;
4230 }
4231
4232 // See pyclasses.h
4233 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4234 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4235 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4236
4237
4238
4239
4240 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4241 {
4242 if (source == Py_None) {
4243 **obj = wxGBPosition(-1,-1);
4244 return true;
4245 }
4246 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4247 }
4248
4249 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4250 {
4251 if (source == Py_None) {
4252 **obj = wxGBSpan(-1,-1);
4253 return true;
4254 }
4255 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4256 }
4257
4258
4259 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4260 wxGBPosition temp, *obj = &temp;
4261 if ( other == Py_None ) return false;
4262 if ( ! wxGBPosition_helper(other, &obj) ) {
4263 PyErr_Clear();
4264 return false;
4265 }
4266 return self->operator==(*obj);
4267 }
4268 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4269 wxGBPosition temp, *obj = &temp;
4270 if ( other == Py_None ) return true;
4271 if ( ! wxGBPosition_helper(other, &obj)) {
4272 PyErr_Clear();
4273 return true;
4274 }
4275 return self->operator!=(*obj);
4276 }
4277 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4278 self->SetRow(row);
4279 self->SetCol(col);
4280 }
4281 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4282 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4283 PyObject* tup = PyTuple_New(2);
4284 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4285 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4286 wxPyEndBlockThreads(blocked);
4287 return tup;
4288 }
4289 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4290 wxGBSpan temp, *obj = &temp;
4291 if ( other == Py_None ) return false;
4292 if ( ! wxGBSpan_helper(other, &obj) ) {
4293 PyErr_Clear();
4294 return false;
4295 }
4296 return self->operator==(*obj);
4297 }
4298 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4299 wxGBSpan temp, *obj = &temp;
4300 if ( other == Py_None ) return true;
4301 if ( ! wxGBSpan_helper(other, &obj)) {
4302 PyErr_Clear();
4303 return true;
4304 }
4305 return self->operator!=(*obj);
4306 }
4307 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4308 self->SetRowspan(rowspan);
4309 self->SetColspan(colspan);
4310 }
4311 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4312 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4313 PyObject* tup = PyTuple_New(2);
4314 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4315 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4316 wxPyEndBlockThreads(blocked);
4317 return tup;
4318 }
4319 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4320 wxPyUserData* data = NULL;
4321 if ( userData ) {
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 data = new wxPyUserData(userData);
4324 wxPyEndBlockThreads(blocked);
4325 }
4326 return new wxGBSizerItem(window, pos, span, flag, border, data);
4327 }
4328 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4329 wxPyUserData* data = NULL;
4330 if ( userData ) {
4331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4332 data = new wxPyUserData(userData);
4333 wxPyEndBlockThreads(blocked);
4334 }
4335 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4336 }
4337 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4338 wxPyUserData* data = NULL;
4339 if ( userData ) {
4340 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4341 data = new wxPyUserData(userData);
4342 wxPyEndBlockThreads(blocked);
4343 }
4344 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4345 }
4346 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4347 int row, col;
4348 self->GetEndPos(row, col);
4349 return wxGBPosition(row, col);
4350 }
4351 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4352
4353 wxPyUserData* data = NULL;
4354 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4355 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4356 if ( userData && (info.window || info.sizer || info.gotSize) )
4357 data = new wxPyUserData(userData);
4358 if ( info.sizer )
4359 PyObject_SetAttrString(item,"thisown",Py_False);
4360 wxPyEndBlockThreads(blocked);
4361
4362 // Now call the real Add method if a valid item type was found
4363 if ( info.window )
4364 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4365 else if ( info.sizer )
4366 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4367 else if (info.gotSize)
4368 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4369 pos, span, flag, border, data);
4370 return NULL;
4371 }
4372
4373
4374 #ifdef __cplusplus
4375 extern "C" {
4376 #endif
4377 SWIGINTERN int EmptyString_set(PyObject *) {
4378 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4379 return 1;
4380 }
4381
4382
4383 SWIGINTERN PyObject *EmptyString_get(void) {
4384 PyObject *pyobj = 0;
4385
4386 {
4387 #if wxUSE_UNICODE
4388 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4389 #else
4390 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4391 #endif
4392 }
4393 return pyobj;
4394 }
4395
4396
4397 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4398 PyObject *resultobj = 0;
4399 wxObject *arg1 = (wxObject *) 0 ;
4400 wxString result;
4401 void *argp1 = 0 ;
4402 int res1 = 0 ;
4403 PyObject *swig_obj[1] ;
4404
4405 if (!args) SWIG_fail;
4406 swig_obj[0] = args;
4407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4408 if (!SWIG_IsOK(res1)) {
4409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4410 }
4411 arg1 = reinterpret_cast< wxObject * >(argp1);
4412 {
4413 PyThreadState* __tstate = wxPyBeginAllowThreads();
4414 result = wxObject_GetClassName(arg1);
4415 wxPyEndAllowThreads(__tstate);
4416 if (PyErr_Occurred()) SWIG_fail;
4417 }
4418 {
4419 #if wxUSE_UNICODE
4420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4421 #else
4422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4423 #endif
4424 }
4425 return resultobj;
4426 fail:
4427 return NULL;
4428 }
4429
4430
4431 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4432 PyObject *resultobj = 0;
4433 wxObject *arg1 = (wxObject *) 0 ;
4434 void *argp1 = 0 ;
4435 int res1 = 0 ;
4436 PyObject *swig_obj[1] ;
4437
4438 if (!args) SWIG_fail;
4439 swig_obj[0] = args;
4440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4441 if (!SWIG_IsOK(res1)) {
4442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4443 }
4444 arg1 = reinterpret_cast< wxObject * >(argp1);
4445 {
4446 PyThreadState* __tstate = wxPyBeginAllowThreads();
4447 wxObject_Destroy(arg1);
4448 wxPyEndAllowThreads(__tstate);
4449 if (PyErr_Occurred()) SWIG_fail;
4450 }
4451 resultobj = SWIG_Py_Void();
4452 return resultobj;
4453 fail:
4454 return NULL;
4455 }
4456
4457
4458 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4459 PyObject *obj;
4460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4461 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4462 return SWIG_Py_Void();
4463 }
4464
4465 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4466 PyObject *resultobj = 0;
4467 wxSize *arg1 = (wxSize *) 0 ;
4468 int arg2 ;
4469 void *argp1 = 0 ;
4470 int res1 = 0 ;
4471 int val2 ;
4472 int ecode2 = 0 ;
4473 PyObject *swig_obj[2] ;
4474
4475 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4477 if (!SWIG_IsOK(res1)) {
4478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4479 }
4480 arg1 = reinterpret_cast< wxSize * >(argp1);
4481 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4482 if (!SWIG_IsOK(ecode2)) {
4483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4484 }
4485 arg2 = static_cast< int >(val2);
4486 if (arg1) (arg1)->x = arg2;
4487
4488 resultobj = SWIG_Py_Void();
4489 return resultobj;
4490 fail:
4491 return NULL;
4492 }
4493
4494
4495 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4496 PyObject *resultobj = 0;
4497 wxSize *arg1 = (wxSize *) 0 ;
4498 int result;
4499 void *argp1 = 0 ;
4500 int res1 = 0 ;
4501 PyObject *swig_obj[1] ;
4502
4503 if (!args) SWIG_fail;
4504 swig_obj[0] = args;
4505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4506 if (!SWIG_IsOK(res1)) {
4507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4508 }
4509 arg1 = reinterpret_cast< wxSize * >(argp1);
4510 result = (int) ((arg1)->x);
4511 resultobj = SWIG_From_int(static_cast< int >(result));
4512 return resultobj;
4513 fail:
4514 return NULL;
4515 }
4516
4517
4518 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4519 PyObject *resultobj = 0;
4520 wxSize *arg1 = (wxSize *) 0 ;
4521 int arg2 ;
4522 void *argp1 = 0 ;
4523 int res1 = 0 ;
4524 int val2 ;
4525 int ecode2 = 0 ;
4526 PyObject *swig_obj[2] ;
4527
4528 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4530 if (!SWIG_IsOK(res1)) {
4531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4532 }
4533 arg1 = reinterpret_cast< wxSize * >(argp1);
4534 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4535 if (!SWIG_IsOK(ecode2)) {
4536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4537 }
4538 arg2 = static_cast< int >(val2);
4539 if (arg1) (arg1)->y = arg2;
4540
4541 resultobj = SWIG_Py_Void();
4542 return resultobj;
4543 fail:
4544 return NULL;
4545 }
4546
4547
4548 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4549 PyObject *resultobj = 0;
4550 wxSize *arg1 = (wxSize *) 0 ;
4551 int result;
4552 void *argp1 = 0 ;
4553 int res1 = 0 ;
4554 PyObject *swig_obj[1] ;
4555
4556 if (!args) SWIG_fail;
4557 swig_obj[0] = args;
4558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4559 if (!SWIG_IsOK(res1)) {
4560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4561 }
4562 arg1 = reinterpret_cast< wxSize * >(argp1);
4563 result = (int) ((arg1)->y);
4564 resultobj = SWIG_From_int(static_cast< int >(result));
4565 return resultobj;
4566 fail:
4567 return NULL;
4568 }
4569
4570
4571 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4572 PyObject *resultobj = 0;
4573 int arg1 = (int) 0 ;
4574 int arg2 = (int) 0 ;
4575 wxSize *result = 0 ;
4576 int val1 ;
4577 int ecode1 = 0 ;
4578 int val2 ;
4579 int ecode2 = 0 ;
4580 PyObject * obj0 = 0 ;
4581 PyObject * obj1 = 0 ;
4582 char * kwnames[] = {
4583 (char *) "w",(char *) "h", NULL
4584 };
4585
4586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4587 if (obj0) {
4588 ecode1 = SWIG_AsVal_int(obj0, &val1);
4589 if (!SWIG_IsOK(ecode1)) {
4590 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4591 }
4592 arg1 = static_cast< int >(val1);
4593 }
4594 if (obj1) {
4595 ecode2 = SWIG_AsVal_int(obj1, &val2);
4596 if (!SWIG_IsOK(ecode2)) {
4597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4598 }
4599 arg2 = static_cast< int >(val2);
4600 }
4601 {
4602 PyThreadState* __tstate = wxPyBeginAllowThreads();
4603 result = (wxSize *)new wxSize(arg1,arg2);
4604 wxPyEndAllowThreads(__tstate);
4605 if (PyErr_Occurred()) SWIG_fail;
4606 }
4607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4608 return resultobj;
4609 fail:
4610 return NULL;
4611 }
4612
4613
4614 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4615 PyObject *resultobj = 0;
4616 wxSize *arg1 = (wxSize *) 0 ;
4617 void *argp1 = 0 ;
4618 int res1 = 0 ;
4619 PyObject *swig_obj[1] ;
4620
4621 if (!args) SWIG_fail;
4622 swig_obj[0] = args;
4623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4624 if (!SWIG_IsOK(res1)) {
4625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4626 }
4627 arg1 = reinterpret_cast< wxSize * >(argp1);
4628 {
4629 PyThreadState* __tstate = wxPyBeginAllowThreads();
4630 delete arg1;
4631
4632 wxPyEndAllowThreads(__tstate);
4633 if (PyErr_Occurred()) SWIG_fail;
4634 }
4635 resultobj = SWIG_Py_Void();
4636 return resultobj;
4637 fail:
4638 return NULL;
4639 }
4640
4641
4642 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4643 PyObject *resultobj = 0;
4644 wxSize *arg1 = (wxSize *) 0 ;
4645 PyObject *arg2 = (PyObject *) 0 ;
4646 bool result;
4647 void *argp1 = 0 ;
4648 int res1 = 0 ;
4649 PyObject * obj0 = 0 ;
4650 PyObject * obj1 = 0 ;
4651 char * kwnames[] = {
4652 (char *) "self",(char *) "other", NULL
4653 };
4654
4655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4657 if (!SWIG_IsOK(res1)) {
4658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4659 }
4660 arg1 = reinterpret_cast< wxSize * >(argp1);
4661 arg2 = obj1;
4662 {
4663 result = (bool)wxSize___eq__(arg1,arg2);
4664 if (PyErr_Occurred()) SWIG_fail;
4665 }
4666 {
4667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4668 }
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 wxSize *arg1 = (wxSize *) 0 ;
4678 PyObject *arg2 = (PyObject *) 0 ;
4679 bool result;
4680 void *argp1 = 0 ;
4681 int res1 = 0 ;
4682 PyObject * obj0 = 0 ;
4683 PyObject * obj1 = 0 ;
4684 char * kwnames[] = {
4685 (char *) "self",(char *) "other", NULL
4686 };
4687
4688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4690 if (!SWIG_IsOK(res1)) {
4691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4692 }
4693 arg1 = reinterpret_cast< wxSize * >(argp1);
4694 arg2 = obj1;
4695 {
4696 result = (bool)wxSize___ne__(arg1,arg2);
4697 if (PyErr_Occurred()) SWIG_fail;
4698 }
4699 {
4700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4701 }
4702 return resultobj;
4703 fail:
4704 return NULL;
4705 }
4706
4707
4708 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4709 PyObject *resultobj = 0;
4710 wxSize *arg1 = (wxSize *) 0 ;
4711 wxSize *arg2 = 0 ;
4712 wxSize result;
4713 void *argp1 = 0 ;
4714 int res1 = 0 ;
4715 wxSize temp2 ;
4716 PyObject * obj0 = 0 ;
4717 PyObject * obj1 = 0 ;
4718 char * kwnames[] = {
4719 (char *) "self",(char *) "sz", NULL
4720 };
4721
4722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4724 if (!SWIG_IsOK(res1)) {
4725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4726 }
4727 arg1 = reinterpret_cast< wxSize * >(argp1);
4728 {
4729 arg2 = &temp2;
4730 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4731 }
4732 {
4733 PyThreadState* __tstate = wxPyBeginAllowThreads();
4734 result = (arg1)->operator +((wxSize const &)*arg2);
4735 wxPyEndAllowThreads(__tstate);
4736 if (PyErr_Occurred()) SWIG_fail;
4737 }
4738 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4739 return resultobj;
4740 fail:
4741 return NULL;
4742 }
4743
4744
4745 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4746 PyObject *resultobj = 0;
4747 wxSize *arg1 = (wxSize *) 0 ;
4748 wxSize *arg2 = 0 ;
4749 wxSize result;
4750 void *argp1 = 0 ;
4751 int res1 = 0 ;
4752 wxSize temp2 ;
4753 PyObject * obj0 = 0 ;
4754 PyObject * obj1 = 0 ;
4755 char * kwnames[] = {
4756 (char *) "self",(char *) "sz", NULL
4757 };
4758
4759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4761 if (!SWIG_IsOK(res1)) {
4762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4763 }
4764 arg1 = reinterpret_cast< wxSize * >(argp1);
4765 {
4766 arg2 = &temp2;
4767 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4768 }
4769 {
4770 PyThreadState* __tstate = wxPyBeginAllowThreads();
4771 result = (arg1)->operator -((wxSize const &)*arg2);
4772 wxPyEndAllowThreads(__tstate);
4773 if (PyErr_Occurred()) SWIG_fail;
4774 }
4775 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4776 return resultobj;
4777 fail:
4778 return NULL;
4779 }
4780
4781
4782 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4783 PyObject *resultobj = 0;
4784 wxSize *arg1 = (wxSize *) 0 ;
4785 wxSize *arg2 = 0 ;
4786 void *argp1 = 0 ;
4787 int res1 = 0 ;
4788 wxSize temp2 ;
4789 PyObject * obj0 = 0 ;
4790 PyObject * obj1 = 0 ;
4791 char * kwnames[] = {
4792 (char *) "self",(char *) "sz", NULL
4793 };
4794
4795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4797 if (!SWIG_IsOK(res1)) {
4798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4799 }
4800 arg1 = reinterpret_cast< wxSize * >(argp1);
4801 {
4802 arg2 = &temp2;
4803 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4804 }
4805 {
4806 PyThreadState* __tstate = wxPyBeginAllowThreads();
4807 (arg1)->IncTo((wxSize const &)*arg2);
4808 wxPyEndAllowThreads(__tstate);
4809 if (PyErr_Occurred()) SWIG_fail;
4810 }
4811 resultobj = SWIG_Py_Void();
4812 return resultobj;
4813 fail:
4814 return NULL;
4815 }
4816
4817
4818 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4819 PyObject *resultobj = 0;
4820 wxSize *arg1 = (wxSize *) 0 ;
4821 wxSize *arg2 = 0 ;
4822 void *argp1 = 0 ;
4823 int res1 = 0 ;
4824 wxSize temp2 ;
4825 PyObject * obj0 = 0 ;
4826 PyObject * obj1 = 0 ;
4827 char * kwnames[] = {
4828 (char *) "self",(char *) "sz", NULL
4829 };
4830
4831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4833 if (!SWIG_IsOK(res1)) {
4834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4835 }
4836 arg1 = reinterpret_cast< wxSize * >(argp1);
4837 {
4838 arg2 = &temp2;
4839 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4840 }
4841 {
4842 PyThreadState* __tstate = wxPyBeginAllowThreads();
4843 (arg1)->DecTo((wxSize const &)*arg2);
4844 wxPyEndAllowThreads(__tstate);
4845 if (PyErr_Occurred()) SWIG_fail;
4846 }
4847 resultobj = SWIG_Py_Void();
4848 return resultobj;
4849 fail:
4850 return NULL;
4851 }
4852
4853
4854 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4855 PyObject *resultobj = 0;
4856 wxSize *arg1 = (wxSize *) 0 ;
4857 float arg2 ;
4858 float arg3 ;
4859 void *argp1 = 0 ;
4860 int res1 = 0 ;
4861 float val2 ;
4862 int ecode2 = 0 ;
4863 float val3 ;
4864 int ecode3 = 0 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 PyObject * obj2 = 0 ;
4868 char * kwnames[] = {
4869 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4870 };
4871
4872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4874 if (!SWIG_IsOK(res1)) {
4875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4876 }
4877 arg1 = reinterpret_cast< wxSize * >(argp1);
4878 ecode2 = SWIG_AsVal_float(obj1, &val2);
4879 if (!SWIG_IsOK(ecode2)) {
4880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4881 }
4882 arg2 = static_cast< float >(val2);
4883 ecode3 = SWIG_AsVal_float(obj2, &val3);
4884 if (!SWIG_IsOK(ecode3)) {
4885 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4886 }
4887 arg3 = static_cast< float >(val3);
4888 {
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 (arg1)->Scale(arg2,arg3);
4891 wxPyEndAllowThreads(__tstate);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_Py_Void();
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4902 PyObject *resultobj = 0;
4903 wxSize *arg1 = (wxSize *) 0 ;
4904 int arg2 ;
4905 int arg3 ;
4906 void *argp1 = 0 ;
4907 int res1 = 0 ;
4908 int val2 ;
4909 int ecode2 = 0 ;
4910 int val3 ;
4911 int ecode3 = 0 ;
4912 PyObject * obj0 = 0 ;
4913 PyObject * obj1 = 0 ;
4914 PyObject * obj2 = 0 ;
4915 char * kwnames[] = {
4916 (char *) "self",(char *) "w",(char *) "h", NULL
4917 };
4918
4919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4921 if (!SWIG_IsOK(res1)) {
4922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4923 }
4924 arg1 = reinterpret_cast< wxSize * >(argp1);
4925 ecode2 = SWIG_AsVal_int(obj1, &val2);
4926 if (!SWIG_IsOK(ecode2)) {
4927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4928 }
4929 arg2 = static_cast< int >(val2);
4930 ecode3 = SWIG_AsVal_int(obj2, &val3);
4931 if (!SWIG_IsOK(ecode3)) {
4932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4933 }
4934 arg3 = static_cast< int >(val3);
4935 {
4936 PyThreadState* __tstate = wxPyBeginAllowThreads();
4937 (arg1)->Set(arg2,arg3);
4938 wxPyEndAllowThreads(__tstate);
4939 if (PyErr_Occurred()) SWIG_fail;
4940 }
4941 resultobj = SWIG_Py_Void();
4942 return resultobj;
4943 fail:
4944 return NULL;
4945 }
4946
4947
4948 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4949 PyObject *resultobj = 0;
4950 wxSize *arg1 = (wxSize *) 0 ;
4951 int arg2 ;
4952 void *argp1 = 0 ;
4953 int res1 = 0 ;
4954 int val2 ;
4955 int ecode2 = 0 ;
4956 PyObject * obj0 = 0 ;
4957 PyObject * obj1 = 0 ;
4958 char * kwnames[] = {
4959 (char *) "self",(char *) "w", NULL
4960 };
4961
4962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4964 if (!SWIG_IsOK(res1)) {
4965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4966 }
4967 arg1 = reinterpret_cast< wxSize * >(argp1);
4968 ecode2 = SWIG_AsVal_int(obj1, &val2);
4969 if (!SWIG_IsOK(ecode2)) {
4970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4971 }
4972 arg2 = static_cast< int >(val2);
4973 {
4974 PyThreadState* __tstate = wxPyBeginAllowThreads();
4975 (arg1)->SetWidth(arg2);
4976 wxPyEndAllowThreads(__tstate);
4977 if (PyErr_Occurred()) SWIG_fail;
4978 }
4979 resultobj = SWIG_Py_Void();
4980 return resultobj;
4981 fail:
4982 return NULL;
4983 }
4984
4985
4986 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4987 PyObject *resultobj = 0;
4988 wxSize *arg1 = (wxSize *) 0 ;
4989 int arg2 ;
4990 void *argp1 = 0 ;
4991 int res1 = 0 ;
4992 int val2 ;
4993 int ecode2 = 0 ;
4994 PyObject * obj0 = 0 ;
4995 PyObject * obj1 = 0 ;
4996 char * kwnames[] = {
4997 (char *) "self",(char *) "h", NULL
4998 };
4999
5000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5002 if (!SWIG_IsOK(res1)) {
5003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5004 }
5005 arg1 = reinterpret_cast< wxSize * >(argp1);
5006 ecode2 = SWIG_AsVal_int(obj1, &val2);
5007 if (!SWIG_IsOK(ecode2)) {
5008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5009 }
5010 arg2 = static_cast< int >(val2);
5011 {
5012 PyThreadState* __tstate = wxPyBeginAllowThreads();
5013 (arg1)->SetHeight(arg2);
5014 wxPyEndAllowThreads(__tstate);
5015 if (PyErr_Occurred()) SWIG_fail;
5016 }
5017 resultobj = SWIG_Py_Void();
5018 return resultobj;
5019 fail:
5020 return NULL;
5021 }
5022
5023
5024 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5025 PyObject *resultobj = 0;
5026 wxSize *arg1 = (wxSize *) 0 ;
5027 int result;
5028 void *argp1 = 0 ;
5029 int res1 = 0 ;
5030 PyObject *swig_obj[1] ;
5031
5032 if (!args) SWIG_fail;
5033 swig_obj[0] = args;
5034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5035 if (!SWIG_IsOK(res1)) {
5036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5037 }
5038 arg1 = reinterpret_cast< wxSize * >(argp1);
5039 {
5040 PyThreadState* __tstate = wxPyBeginAllowThreads();
5041 result = (int)((wxSize const *)arg1)->GetWidth();
5042 wxPyEndAllowThreads(__tstate);
5043 if (PyErr_Occurred()) SWIG_fail;
5044 }
5045 resultobj = SWIG_From_int(static_cast< int >(result));
5046 return resultobj;
5047 fail:
5048 return NULL;
5049 }
5050
5051
5052 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5053 PyObject *resultobj = 0;
5054 wxSize *arg1 = (wxSize *) 0 ;
5055 int result;
5056 void *argp1 = 0 ;
5057 int res1 = 0 ;
5058 PyObject *swig_obj[1] ;
5059
5060 if (!args) SWIG_fail;
5061 swig_obj[0] = args;
5062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5063 if (!SWIG_IsOK(res1)) {
5064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5065 }
5066 arg1 = reinterpret_cast< wxSize * >(argp1);
5067 {
5068 PyThreadState* __tstate = wxPyBeginAllowThreads();
5069 result = (int)((wxSize const *)arg1)->GetHeight();
5070 wxPyEndAllowThreads(__tstate);
5071 if (PyErr_Occurred()) SWIG_fail;
5072 }
5073 resultobj = SWIG_From_int(static_cast< int >(result));
5074 return resultobj;
5075 fail:
5076 return NULL;
5077 }
5078
5079
5080 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5081 PyObject *resultobj = 0;
5082 wxSize *arg1 = (wxSize *) 0 ;
5083 bool result;
5084 void *argp1 = 0 ;
5085 int res1 = 0 ;
5086 PyObject *swig_obj[1] ;
5087
5088 if (!args) SWIG_fail;
5089 swig_obj[0] = args;
5090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5091 if (!SWIG_IsOK(res1)) {
5092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5093 }
5094 arg1 = reinterpret_cast< wxSize * >(argp1);
5095 {
5096 PyThreadState* __tstate = wxPyBeginAllowThreads();
5097 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5098 wxPyEndAllowThreads(__tstate);
5099 if (PyErr_Occurred()) SWIG_fail;
5100 }
5101 {
5102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5103 }
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = 0;
5112 wxSize *arg1 = (wxSize *) 0 ;
5113 wxSize *arg2 = 0 ;
5114 void *argp1 = 0 ;
5115 int res1 = 0 ;
5116 wxSize temp2 ;
5117 PyObject * obj0 = 0 ;
5118 PyObject * obj1 = 0 ;
5119 char * kwnames[] = {
5120 (char *) "self",(char *) "size", NULL
5121 };
5122
5123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5125 if (!SWIG_IsOK(res1)) {
5126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5127 }
5128 arg1 = reinterpret_cast< wxSize * >(argp1);
5129 {
5130 arg2 = &temp2;
5131 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5132 }
5133 {
5134 PyThreadState* __tstate = wxPyBeginAllowThreads();
5135 (arg1)->SetDefaults((wxSize const &)*arg2);
5136 wxPyEndAllowThreads(__tstate);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 resultobj = SWIG_Py_Void();
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5147 PyObject *resultobj = 0;
5148 wxSize *arg1 = (wxSize *) 0 ;
5149 PyObject *result = 0 ;
5150 void *argp1 = 0 ;
5151 int res1 = 0 ;
5152 PyObject *swig_obj[1] ;
5153
5154 if (!args) SWIG_fail;
5155 swig_obj[0] = args;
5156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5157 if (!SWIG_IsOK(res1)) {
5158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5159 }
5160 arg1 = reinterpret_cast< wxSize * >(argp1);
5161 {
5162 PyThreadState* __tstate = wxPyBeginAllowThreads();
5163 result = (PyObject *)wxSize_Get(arg1);
5164 wxPyEndAllowThreads(__tstate);
5165 if (PyErr_Occurred()) SWIG_fail;
5166 }
5167 resultobj = result;
5168 return resultobj;
5169 fail:
5170 return NULL;
5171 }
5172
5173
5174 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5175 PyObject *obj;
5176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5177 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5178 return SWIG_Py_Void();
5179 }
5180
5181 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5182 return SWIG_Python_InitShadowInstance(args);
5183 }
5184
5185 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5186 PyObject *resultobj = 0;
5187 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5188 double arg2 ;
5189 void *argp1 = 0 ;
5190 int res1 = 0 ;
5191 double val2 ;
5192 int ecode2 = 0 ;
5193 PyObject *swig_obj[2] ;
5194
5195 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5197 if (!SWIG_IsOK(res1)) {
5198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5199 }
5200 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5201 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5202 if (!SWIG_IsOK(ecode2)) {
5203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5204 }
5205 arg2 = static_cast< double >(val2);
5206 if (arg1) (arg1)->x = arg2;
5207
5208 resultobj = SWIG_Py_Void();
5209 return resultobj;
5210 fail:
5211 return NULL;
5212 }
5213
5214
5215 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5216 PyObject *resultobj = 0;
5217 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5218 double result;
5219 void *argp1 = 0 ;
5220 int res1 = 0 ;
5221 PyObject *swig_obj[1] ;
5222
5223 if (!args) SWIG_fail;
5224 swig_obj[0] = args;
5225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5226 if (!SWIG_IsOK(res1)) {
5227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5228 }
5229 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5230 result = (double) ((arg1)->x);
5231 resultobj = SWIG_From_double(static_cast< double >(result));
5232 return resultobj;
5233 fail:
5234 return NULL;
5235 }
5236
5237
5238 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5239 PyObject *resultobj = 0;
5240 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5241 double arg2 ;
5242 void *argp1 = 0 ;
5243 int res1 = 0 ;
5244 double val2 ;
5245 int ecode2 = 0 ;
5246 PyObject *swig_obj[2] ;
5247
5248 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5250 if (!SWIG_IsOK(res1)) {
5251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5252 }
5253 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5254 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5255 if (!SWIG_IsOK(ecode2)) {
5256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5257 }
5258 arg2 = static_cast< double >(val2);
5259 if (arg1) (arg1)->y = arg2;
5260
5261 resultobj = SWIG_Py_Void();
5262 return resultobj;
5263 fail:
5264 return NULL;
5265 }
5266
5267
5268 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5269 PyObject *resultobj = 0;
5270 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5271 double result;
5272 void *argp1 = 0 ;
5273 int res1 = 0 ;
5274 PyObject *swig_obj[1] ;
5275
5276 if (!args) SWIG_fail;
5277 swig_obj[0] = args;
5278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5279 if (!SWIG_IsOK(res1)) {
5280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5281 }
5282 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5283 result = (double) ((arg1)->y);
5284 resultobj = SWIG_From_double(static_cast< double >(result));
5285 return resultobj;
5286 fail:
5287 return NULL;
5288 }
5289
5290
5291 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5292 PyObject *resultobj = 0;
5293 double arg1 = (double) 0.0 ;
5294 double arg2 = (double) 0.0 ;
5295 wxRealPoint *result = 0 ;
5296 double val1 ;
5297 int ecode1 = 0 ;
5298 double val2 ;
5299 int ecode2 = 0 ;
5300 PyObject * obj0 = 0 ;
5301 PyObject * obj1 = 0 ;
5302 char * kwnames[] = {
5303 (char *) "x",(char *) "y", NULL
5304 };
5305
5306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5307 if (obj0) {
5308 ecode1 = SWIG_AsVal_double(obj0, &val1);
5309 if (!SWIG_IsOK(ecode1)) {
5310 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5311 }
5312 arg1 = static_cast< double >(val1);
5313 }
5314 if (obj1) {
5315 ecode2 = SWIG_AsVal_double(obj1, &val2);
5316 if (!SWIG_IsOK(ecode2)) {
5317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5318 }
5319 arg2 = static_cast< double >(val2);
5320 }
5321 {
5322 PyThreadState* __tstate = wxPyBeginAllowThreads();
5323 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5324 wxPyEndAllowThreads(__tstate);
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5328 return resultobj;
5329 fail:
5330 return NULL;
5331 }
5332
5333
5334 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5335 PyObject *resultobj = 0;
5336 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5337 void *argp1 = 0 ;
5338 int res1 = 0 ;
5339 PyObject *swig_obj[1] ;
5340
5341 if (!args) SWIG_fail;
5342 swig_obj[0] = args;
5343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5344 if (!SWIG_IsOK(res1)) {
5345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5346 }
5347 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5348 {
5349 PyThreadState* __tstate = wxPyBeginAllowThreads();
5350 delete arg1;
5351
5352 wxPyEndAllowThreads(__tstate);
5353 if (PyErr_Occurred()) SWIG_fail;
5354 }
5355 resultobj = SWIG_Py_Void();
5356 return resultobj;
5357 fail:
5358 return NULL;
5359 }
5360
5361
5362 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5363 PyObject *resultobj = 0;
5364 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5365 PyObject *arg2 = (PyObject *) 0 ;
5366 bool result;
5367 void *argp1 = 0 ;
5368 int res1 = 0 ;
5369 PyObject * obj0 = 0 ;
5370 PyObject * obj1 = 0 ;
5371 char * kwnames[] = {
5372 (char *) "self",(char *) "other", NULL
5373 };
5374
5375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5377 if (!SWIG_IsOK(res1)) {
5378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5379 }
5380 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5381 arg2 = obj1;
5382 {
5383 result = (bool)wxRealPoint___eq__(arg1,arg2);
5384 if (PyErr_Occurred()) SWIG_fail;
5385 }
5386 {
5387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5388 }
5389 return resultobj;
5390 fail:
5391 return NULL;
5392 }
5393
5394
5395 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5396 PyObject *resultobj = 0;
5397 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5398 PyObject *arg2 = (PyObject *) 0 ;
5399 bool result;
5400 void *argp1 = 0 ;
5401 int res1 = 0 ;
5402 PyObject * obj0 = 0 ;
5403 PyObject * obj1 = 0 ;
5404 char * kwnames[] = {
5405 (char *) "self",(char *) "other", NULL
5406 };
5407
5408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5410 if (!SWIG_IsOK(res1)) {
5411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5412 }
5413 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5414 arg2 = obj1;
5415 {
5416 result = (bool)wxRealPoint___ne__(arg1,arg2);
5417 if (PyErr_Occurred()) SWIG_fail;
5418 }
5419 {
5420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5421 }
5422 return resultobj;
5423 fail:
5424 return NULL;
5425 }
5426
5427
5428 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5429 PyObject *resultobj = 0;
5430 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5431 wxRealPoint *arg2 = 0 ;
5432 wxRealPoint result;
5433 void *argp1 = 0 ;
5434 int res1 = 0 ;
5435 wxRealPoint temp2 ;
5436 PyObject * obj0 = 0 ;
5437 PyObject * obj1 = 0 ;
5438 char * kwnames[] = {
5439 (char *) "self",(char *) "pt", NULL
5440 };
5441
5442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5444 if (!SWIG_IsOK(res1)) {
5445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5446 }
5447 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5448 {
5449 arg2 = &temp2;
5450 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5451 }
5452 {
5453 PyThreadState* __tstate = wxPyBeginAllowThreads();
5454 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5455 wxPyEndAllowThreads(__tstate);
5456 if (PyErr_Occurred()) SWIG_fail;
5457 }
5458 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5459 return resultobj;
5460 fail:
5461 return NULL;
5462 }
5463
5464
5465 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5466 PyObject *resultobj = 0;
5467 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5468 wxRealPoint *arg2 = 0 ;
5469 wxRealPoint result;
5470 void *argp1 = 0 ;
5471 int res1 = 0 ;
5472 wxRealPoint temp2 ;
5473 PyObject * obj0 = 0 ;
5474 PyObject * obj1 = 0 ;
5475 char * kwnames[] = {
5476 (char *) "self",(char *) "pt", NULL
5477 };
5478
5479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5481 if (!SWIG_IsOK(res1)) {
5482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5483 }
5484 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5485 {
5486 arg2 = &temp2;
5487 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5488 }
5489 {
5490 PyThreadState* __tstate = wxPyBeginAllowThreads();
5491 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5492 wxPyEndAllowThreads(__tstate);
5493 if (PyErr_Occurred()) SWIG_fail;
5494 }
5495 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5496 return resultobj;
5497 fail:
5498 return NULL;
5499 }
5500
5501
5502 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5503 PyObject *resultobj = 0;
5504 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5505 double arg2 ;
5506 double arg3 ;
5507 void *argp1 = 0 ;
5508 int res1 = 0 ;
5509 double val2 ;
5510 int ecode2 = 0 ;
5511 double val3 ;
5512 int ecode3 = 0 ;
5513 PyObject * obj0 = 0 ;
5514 PyObject * obj1 = 0 ;
5515 PyObject * obj2 = 0 ;
5516 char * kwnames[] = {
5517 (char *) "self",(char *) "x",(char *) "y", NULL
5518 };
5519
5520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5522 if (!SWIG_IsOK(res1)) {
5523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5524 }
5525 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5526 ecode2 = SWIG_AsVal_double(obj1, &val2);
5527 if (!SWIG_IsOK(ecode2)) {
5528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5529 }
5530 arg2 = static_cast< double >(val2);
5531 ecode3 = SWIG_AsVal_double(obj2, &val3);
5532 if (!SWIG_IsOK(ecode3)) {
5533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5534 }
5535 arg3 = static_cast< double >(val3);
5536 {
5537 PyThreadState* __tstate = wxPyBeginAllowThreads();
5538 wxRealPoint_Set(arg1,arg2,arg3);
5539 wxPyEndAllowThreads(__tstate);
5540 if (PyErr_Occurred()) SWIG_fail;
5541 }
5542 resultobj = SWIG_Py_Void();
5543 return resultobj;
5544 fail:
5545 return NULL;
5546 }
5547
5548
5549 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5550 PyObject *resultobj = 0;
5551 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5552 PyObject *result = 0 ;
5553 void *argp1 = 0 ;
5554 int res1 = 0 ;
5555 PyObject *swig_obj[1] ;
5556
5557 if (!args) SWIG_fail;
5558 swig_obj[0] = args;
5559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5560 if (!SWIG_IsOK(res1)) {
5561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5562 }
5563 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5564 {
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 result = (PyObject *)wxRealPoint_Get(arg1);
5567 wxPyEndAllowThreads(__tstate);
5568 if (PyErr_Occurred()) SWIG_fail;
5569 }
5570 resultobj = result;
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5578 PyObject *obj;
5579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5580 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5581 return SWIG_Py_Void();
5582 }
5583
5584 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5585 return SWIG_Python_InitShadowInstance(args);
5586 }
5587
5588 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5589 PyObject *resultobj = 0;
5590 wxPoint *arg1 = (wxPoint *) 0 ;
5591 int arg2 ;
5592 void *argp1 = 0 ;
5593 int res1 = 0 ;
5594 int val2 ;
5595 int ecode2 = 0 ;
5596 PyObject *swig_obj[2] ;
5597
5598 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5600 if (!SWIG_IsOK(res1)) {
5601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5602 }
5603 arg1 = reinterpret_cast< wxPoint * >(argp1);
5604 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5605 if (!SWIG_IsOK(ecode2)) {
5606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5607 }
5608 arg2 = static_cast< int >(val2);
5609 if (arg1) (arg1)->x = arg2;
5610
5611 resultobj = SWIG_Py_Void();
5612 return resultobj;
5613 fail:
5614 return NULL;
5615 }
5616
5617
5618 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5619 PyObject *resultobj = 0;
5620 wxPoint *arg1 = (wxPoint *) 0 ;
5621 int result;
5622 void *argp1 = 0 ;
5623 int res1 = 0 ;
5624 PyObject *swig_obj[1] ;
5625
5626 if (!args) SWIG_fail;
5627 swig_obj[0] = args;
5628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5629 if (!SWIG_IsOK(res1)) {
5630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5631 }
5632 arg1 = reinterpret_cast< wxPoint * >(argp1);
5633 result = (int) ((arg1)->x);
5634 resultobj = SWIG_From_int(static_cast< int >(result));
5635 return resultobj;
5636 fail:
5637 return NULL;
5638 }
5639
5640
5641 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5642 PyObject *resultobj = 0;
5643 wxPoint *arg1 = (wxPoint *) 0 ;
5644 int arg2 ;
5645 void *argp1 = 0 ;
5646 int res1 = 0 ;
5647 int val2 ;
5648 int ecode2 = 0 ;
5649 PyObject *swig_obj[2] ;
5650
5651 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5653 if (!SWIG_IsOK(res1)) {
5654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5655 }
5656 arg1 = reinterpret_cast< wxPoint * >(argp1);
5657 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5658 if (!SWIG_IsOK(ecode2)) {
5659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5660 }
5661 arg2 = static_cast< int >(val2);
5662 if (arg1) (arg1)->y = arg2;
5663
5664 resultobj = SWIG_Py_Void();
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5672 PyObject *resultobj = 0;
5673 wxPoint *arg1 = (wxPoint *) 0 ;
5674 int result;
5675 void *argp1 = 0 ;
5676 int res1 = 0 ;
5677 PyObject *swig_obj[1] ;
5678
5679 if (!args) SWIG_fail;
5680 swig_obj[0] = args;
5681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5682 if (!SWIG_IsOK(res1)) {
5683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5684 }
5685 arg1 = reinterpret_cast< wxPoint * >(argp1);
5686 result = (int) ((arg1)->y);
5687 resultobj = SWIG_From_int(static_cast< int >(result));
5688 return resultobj;
5689 fail:
5690 return NULL;
5691 }
5692
5693
5694 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5695 PyObject *resultobj = 0;
5696 int arg1 = (int) 0 ;
5697 int arg2 = (int) 0 ;
5698 wxPoint *result = 0 ;
5699 int val1 ;
5700 int ecode1 = 0 ;
5701 int val2 ;
5702 int ecode2 = 0 ;
5703 PyObject * obj0 = 0 ;
5704 PyObject * obj1 = 0 ;
5705 char * kwnames[] = {
5706 (char *) "x",(char *) "y", NULL
5707 };
5708
5709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5710 if (obj0) {
5711 ecode1 = SWIG_AsVal_int(obj0, &val1);
5712 if (!SWIG_IsOK(ecode1)) {
5713 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5714 }
5715 arg1 = static_cast< int >(val1);
5716 }
5717 if (obj1) {
5718 ecode2 = SWIG_AsVal_int(obj1, &val2);
5719 if (!SWIG_IsOK(ecode2)) {
5720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5721 }
5722 arg2 = static_cast< int >(val2);
5723 }
5724 {
5725 PyThreadState* __tstate = wxPyBeginAllowThreads();
5726 result = (wxPoint *)new wxPoint(arg1,arg2);
5727 wxPyEndAllowThreads(__tstate);
5728 if (PyErr_Occurred()) SWIG_fail;
5729 }
5730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5731 return resultobj;
5732 fail:
5733 return NULL;
5734 }
5735
5736
5737 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5738 PyObject *resultobj = 0;
5739 wxPoint *arg1 = (wxPoint *) 0 ;
5740 void *argp1 = 0 ;
5741 int res1 = 0 ;
5742 PyObject *swig_obj[1] ;
5743
5744 if (!args) SWIG_fail;
5745 swig_obj[0] = args;
5746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5747 if (!SWIG_IsOK(res1)) {
5748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5749 }
5750 arg1 = reinterpret_cast< wxPoint * >(argp1);
5751 {
5752 PyThreadState* __tstate = wxPyBeginAllowThreads();
5753 delete arg1;
5754
5755 wxPyEndAllowThreads(__tstate);
5756 if (PyErr_Occurred()) SWIG_fail;
5757 }
5758 resultobj = SWIG_Py_Void();
5759 return resultobj;
5760 fail:
5761 return NULL;
5762 }
5763
5764
5765 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5766 PyObject *resultobj = 0;
5767 wxPoint *arg1 = (wxPoint *) 0 ;
5768 PyObject *arg2 = (PyObject *) 0 ;
5769 bool result;
5770 void *argp1 = 0 ;
5771 int res1 = 0 ;
5772 PyObject * obj0 = 0 ;
5773 PyObject * obj1 = 0 ;
5774 char * kwnames[] = {
5775 (char *) "self",(char *) "other", NULL
5776 };
5777
5778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5780 if (!SWIG_IsOK(res1)) {
5781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5782 }
5783 arg1 = reinterpret_cast< wxPoint * >(argp1);
5784 arg2 = obj1;
5785 {
5786 result = (bool)wxPoint___eq__(arg1,arg2);
5787 if (PyErr_Occurred()) SWIG_fail;
5788 }
5789 {
5790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5791 }
5792 return resultobj;
5793 fail:
5794 return NULL;
5795 }
5796
5797
5798 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5799 PyObject *resultobj = 0;
5800 wxPoint *arg1 = (wxPoint *) 0 ;
5801 PyObject *arg2 = (PyObject *) 0 ;
5802 bool result;
5803 void *argp1 = 0 ;
5804 int res1 = 0 ;
5805 PyObject * obj0 = 0 ;
5806 PyObject * obj1 = 0 ;
5807 char * kwnames[] = {
5808 (char *) "self",(char *) "other", NULL
5809 };
5810
5811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5813 if (!SWIG_IsOK(res1)) {
5814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5815 }
5816 arg1 = reinterpret_cast< wxPoint * >(argp1);
5817 arg2 = obj1;
5818 {
5819 result = (bool)wxPoint___ne__(arg1,arg2);
5820 if (PyErr_Occurred()) SWIG_fail;
5821 }
5822 {
5823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5824 }
5825 return resultobj;
5826 fail:
5827 return NULL;
5828 }
5829
5830
5831 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5832 PyObject *resultobj = 0;
5833 wxPoint *arg1 = (wxPoint *) 0 ;
5834 wxPoint *arg2 = 0 ;
5835 wxPoint result;
5836 void *argp1 = 0 ;
5837 int res1 = 0 ;
5838 wxPoint temp2 ;
5839 PyObject * obj0 = 0 ;
5840 PyObject * obj1 = 0 ;
5841 char * kwnames[] = {
5842 (char *) "self",(char *) "pt", NULL
5843 };
5844
5845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5847 if (!SWIG_IsOK(res1)) {
5848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5849 }
5850 arg1 = reinterpret_cast< wxPoint * >(argp1);
5851 {
5852 arg2 = &temp2;
5853 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5854 }
5855 {
5856 PyThreadState* __tstate = wxPyBeginAllowThreads();
5857 result = (arg1)->operator +((wxPoint const &)*arg2);
5858 wxPyEndAllowThreads(__tstate);
5859 if (PyErr_Occurred()) SWIG_fail;
5860 }
5861 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5862 return resultobj;
5863 fail:
5864 return NULL;
5865 }
5866
5867
5868 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5869 PyObject *resultobj = 0;
5870 wxPoint *arg1 = (wxPoint *) 0 ;
5871 wxPoint *arg2 = 0 ;
5872 wxPoint result;
5873 void *argp1 = 0 ;
5874 int res1 = 0 ;
5875 wxPoint temp2 ;
5876 PyObject * obj0 = 0 ;
5877 PyObject * obj1 = 0 ;
5878 char * kwnames[] = {
5879 (char *) "self",(char *) "pt", NULL
5880 };
5881
5882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5884 if (!SWIG_IsOK(res1)) {
5885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5886 }
5887 arg1 = reinterpret_cast< wxPoint * >(argp1);
5888 {
5889 arg2 = &temp2;
5890 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5891 }
5892 {
5893 PyThreadState* __tstate = wxPyBeginAllowThreads();
5894 result = (arg1)->operator -((wxPoint const &)*arg2);
5895 wxPyEndAllowThreads(__tstate);
5896 if (PyErr_Occurred()) SWIG_fail;
5897 }
5898 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5899 return resultobj;
5900 fail:
5901 return NULL;
5902 }
5903
5904
5905 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5906 PyObject *resultobj = 0;
5907 wxPoint *arg1 = (wxPoint *) 0 ;
5908 wxPoint *arg2 = 0 ;
5909 wxPoint *result = 0 ;
5910 void *argp1 = 0 ;
5911 int res1 = 0 ;
5912 wxPoint temp2 ;
5913 PyObject * obj0 = 0 ;
5914 PyObject * obj1 = 0 ;
5915 char * kwnames[] = {
5916 (char *) "self",(char *) "pt", NULL
5917 };
5918
5919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5921 if (!SWIG_IsOK(res1)) {
5922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5923 }
5924 arg1 = reinterpret_cast< wxPoint * >(argp1);
5925 {
5926 arg2 = &temp2;
5927 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5928 }
5929 {
5930 PyThreadState* __tstate = wxPyBeginAllowThreads();
5931 {
5932 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5933 result = (wxPoint *) &_result_ref;
5934 }
5935 wxPyEndAllowThreads(__tstate);
5936 if (PyErr_Occurred()) SWIG_fail;
5937 }
5938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5946 PyObject *resultobj = 0;
5947 wxPoint *arg1 = (wxPoint *) 0 ;
5948 wxPoint *arg2 = 0 ;
5949 wxPoint *result = 0 ;
5950 void *argp1 = 0 ;
5951 int res1 = 0 ;
5952 wxPoint temp2 ;
5953 PyObject * obj0 = 0 ;
5954 PyObject * obj1 = 0 ;
5955 char * kwnames[] = {
5956 (char *) "self",(char *) "pt", NULL
5957 };
5958
5959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5961 if (!SWIG_IsOK(res1)) {
5962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5963 }
5964 arg1 = reinterpret_cast< wxPoint * >(argp1);
5965 {
5966 arg2 = &temp2;
5967 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5968 }
5969 {
5970 PyThreadState* __tstate = wxPyBeginAllowThreads();
5971 {
5972 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5973 result = (wxPoint *) &_result_ref;
5974 }
5975 wxPyEndAllowThreads(__tstate);
5976 if (PyErr_Occurred()) SWIG_fail;
5977 }
5978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5979 return resultobj;
5980 fail:
5981 return NULL;
5982 }
5983
5984
5985 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5986 PyObject *resultobj = 0;
5987 wxPoint *arg1 = (wxPoint *) 0 ;
5988 long arg2 ;
5989 long arg3 ;
5990 void *argp1 = 0 ;
5991 int res1 = 0 ;
5992 long val2 ;
5993 int ecode2 = 0 ;
5994 long val3 ;
5995 int ecode3 = 0 ;
5996 PyObject * obj0 = 0 ;
5997 PyObject * obj1 = 0 ;
5998 PyObject * obj2 = 0 ;
5999 char * kwnames[] = {
6000 (char *) "self",(char *) "x",(char *) "y", NULL
6001 };
6002
6003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6005 if (!SWIG_IsOK(res1)) {
6006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6007 }
6008 arg1 = reinterpret_cast< wxPoint * >(argp1);
6009 ecode2 = SWIG_AsVal_long(obj1, &val2);
6010 if (!SWIG_IsOK(ecode2)) {
6011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6012 }
6013 arg2 = static_cast< long >(val2);
6014 ecode3 = SWIG_AsVal_long(obj2, &val3);
6015 if (!SWIG_IsOK(ecode3)) {
6016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6017 }
6018 arg3 = static_cast< long >(val3);
6019 {
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 wxPoint_Set(arg1,arg2,arg3);
6022 wxPyEndAllowThreads(__tstate);
6023 if (PyErr_Occurred()) SWIG_fail;
6024 }
6025 resultobj = SWIG_Py_Void();
6026 return resultobj;
6027 fail:
6028 return NULL;
6029 }
6030
6031
6032 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6033 PyObject *resultobj = 0;
6034 wxPoint *arg1 = (wxPoint *) 0 ;
6035 PyObject *result = 0 ;
6036 void *argp1 = 0 ;
6037 int res1 = 0 ;
6038 PyObject *swig_obj[1] ;
6039
6040 if (!args) SWIG_fail;
6041 swig_obj[0] = args;
6042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6043 if (!SWIG_IsOK(res1)) {
6044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6045 }
6046 arg1 = reinterpret_cast< wxPoint * >(argp1);
6047 {
6048 PyThreadState* __tstate = wxPyBeginAllowThreads();
6049 result = (PyObject *)wxPoint_Get(arg1);
6050 wxPyEndAllowThreads(__tstate);
6051 if (PyErr_Occurred()) SWIG_fail;
6052 }
6053 resultobj = result;
6054 return resultobj;
6055 fail:
6056 return NULL;
6057 }
6058
6059
6060 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6061 PyObject *obj;
6062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6063 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6064 return SWIG_Py_Void();
6065 }
6066
6067 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6068 return SWIG_Python_InitShadowInstance(args);
6069 }
6070
6071 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj = 0;
6073 int arg1 = (int) 0 ;
6074 int arg2 = (int) 0 ;
6075 int arg3 = (int) 0 ;
6076 int arg4 = (int) 0 ;
6077 wxRect *result = 0 ;
6078 int val1 ;
6079 int ecode1 = 0 ;
6080 int val2 ;
6081 int ecode2 = 0 ;
6082 int val3 ;
6083 int ecode3 = 0 ;
6084 int val4 ;
6085 int ecode4 = 0 ;
6086 PyObject * obj0 = 0 ;
6087 PyObject * obj1 = 0 ;
6088 PyObject * obj2 = 0 ;
6089 PyObject * obj3 = 0 ;
6090 char * kwnames[] = {
6091 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6092 };
6093
6094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6095 if (obj0) {
6096 ecode1 = SWIG_AsVal_int(obj0, &val1);
6097 if (!SWIG_IsOK(ecode1)) {
6098 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6099 }
6100 arg1 = static_cast< int >(val1);
6101 }
6102 if (obj1) {
6103 ecode2 = SWIG_AsVal_int(obj1, &val2);
6104 if (!SWIG_IsOK(ecode2)) {
6105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6106 }
6107 arg2 = static_cast< int >(val2);
6108 }
6109 if (obj2) {
6110 ecode3 = SWIG_AsVal_int(obj2, &val3);
6111 if (!SWIG_IsOK(ecode3)) {
6112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6113 }
6114 arg3 = static_cast< int >(val3);
6115 }
6116 if (obj3) {
6117 ecode4 = SWIG_AsVal_int(obj3, &val4);
6118 if (!SWIG_IsOK(ecode4)) {
6119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6120 }
6121 arg4 = static_cast< int >(val4);
6122 }
6123 {
6124 PyThreadState* __tstate = wxPyBeginAllowThreads();
6125 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6126 wxPyEndAllowThreads(__tstate);
6127 if (PyErr_Occurred()) SWIG_fail;
6128 }
6129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6130 return resultobj;
6131 fail:
6132 return NULL;
6133 }
6134
6135
6136 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6137 PyObject *resultobj = 0;
6138 wxPoint *arg1 = 0 ;
6139 wxPoint *arg2 = 0 ;
6140 wxRect *result = 0 ;
6141 wxPoint temp1 ;
6142 wxPoint temp2 ;
6143 PyObject * obj0 = 0 ;
6144 PyObject * obj1 = 0 ;
6145 char * kwnames[] = {
6146 (char *) "topLeft",(char *) "bottomRight", NULL
6147 };
6148
6149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6150 {
6151 arg1 = &temp1;
6152 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6153 }
6154 {
6155 arg2 = &temp2;
6156 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6157 }
6158 {
6159 PyThreadState* __tstate = wxPyBeginAllowThreads();
6160 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6161 wxPyEndAllowThreads(__tstate);
6162 if (PyErr_Occurred()) SWIG_fail;
6163 }
6164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6165 return resultobj;
6166 fail:
6167 return NULL;
6168 }
6169
6170
6171 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6172 PyObject *resultobj = 0;
6173 wxPoint *arg1 = 0 ;
6174 wxSize *arg2 = 0 ;
6175 wxRect *result = 0 ;
6176 wxPoint temp1 ;
6177 wxSize temp2 ;
6178 PyObject * obj0 = 0 ;
6179 PyObject * obj1 = 0 ;
6180 char * kwnames[] = {
6181 (char *) "pos",(char *) "size", NULL
6182 };
6183
6184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6185 {
6186 arg1 = &temp1;
6187 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6188 }
6189 {
6190 arg2 = &temp2;
6191 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6192 }
6193 {
6194 PyThreadState* __tstate = wxPyBeginAllowThreads();
6195 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6196 wxPyEndAllowThreads(__tstate);
6197 if (PyErr_Occurred()) SWIG_fail;
6198 }
6199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj = 0;
6208 wxSize *arg1 = 0 ;
6209 wxRect *result = 0 ;
6210 wxSize temp1 ;
6211 PyObject * obj0 = 0 ;
6212 char * kwnames[] = {
6213 (char *) "size", NULL
6214 };
6215
6216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6217 {
6218 arg1 = &temp1;
6219 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6220 }
6221 {
6222 PyThreadState* __tstate = wxPyBeginAllowThreads();
6223 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6224 wxPyEndAllowThreads(__tstate);
6225 if (PyErr_Occurred()) SWIG_fail;
6226 }
6227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6228 return resultobj;
6229 fail:
6230 return NULL;
6231 }
6232
6233
6234 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6235 PyObject *resultobj = 0;
6236 wxRect *arg1 = (wxRect *) 0 ;
6237 void *argp1 = 0 ;
6238 int res1 = 0 ;
6239 PyObject *swig_obj[1] ;
6240
6241 if (!args) SWIG_fail;
6242 swig_obj[0] = args;
6243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6244 if (!SWIG_IsOK(res1)) {
6245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6246 }
6247 arg1 = reinterpret_cast< wxRect * >(argp1);
6248 {
6249 PyThreadState* __tstate = wxPyBeginAllowThreads();
6250 delete arg1;
6251
6252 wxPyEndAllowThreads(__tstate);
6253 if (PyErr_Occurred()) SWIG_fail;
6254 }
6255 resultobj = SWIG_Py_Void();
6256 return resultobj;
6257 fail:
6258 return NULL;
6259 }
6260
6261
6262 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6263 PyObject *resultobj = 0;
6264 wxRect *arg1 = (wxRect *) 0 ;
6265 int result;
6266 void *argp1 = 0 ;
6267 int res1 = 0 ;
6268 PyObject *swig_obj[1] ;
6269
6270 if (!args) SWIG_fail;
6271 swig_obj[0] = args;
6272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6273 if (!SWIG_IsOK(res1)) {
6274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6275 }
6276 arg1 = reinterpret_cast< wxRect * >(argp1);
6277 {
6278 PyThreadState* __tstate = wxPyBeginAllowThreads();
6279 result = (int)((wxRect const *)arg1)->GetX();
6280 wxPyEndAllowThreads(__tstate);
6281 if (PyErr_Occurred()) SWIG_fail;
6282 }
6283 resultobj = SWIG_From_int(static_cast< int >(result));
6284 return resultobj;
6285 fail:
6286 return NULL;
6287 }
6288
6289
6290 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6291 PyObject *resultobj = 0;
6292 wxRect *arg1 = (wxRect *) 0 ;
6293 int arg2 ;
6294 void *argp1 = 0 ;
6295 int res1 = 0 ;
6296 int val2 ;
6297 int ecode2 = 0 ;
6298 PyObject * obj0 = 0 ;
6299 PyObject * obj1 = 0 ;
6300 char * kwnames[] = {
6301 (char *) "self",(char *) "x", NULL
6302 };
6303
6304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6306 if (!SWIG_IsOK(res1)) {
6307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6308 }
6309 arg1 = reinterpret_cast< wxRect * >(argp1);
6310 ecode2 = SWIG_AsVal_int(obj1, &val2);
6311 if (!SWIG_IsOK(ecode2)) {
6312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6313 }
6314 arg2 = static_cast< int >(val2);
6315 {
6316 PyThreadState* __tstate = wxPyBeginAllowThreads();
6317 (arg1)->SetX(arg2);
6318 wxPyEndAllowThreads(__tstate);
6319 if (PyErr_Occurred()) SWIG_fail;
6320 }
6321 resultobj = SWIG_Py_Void();
6322 return resultobj;
6323 fail:
6324 return NULL;
6325 }
6326
6327
6328 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6329 PyObject *resultobj = 0;
6330 wxRect *arg1 = (wxRect *) 0 ;
6331 int result;
6332 void *argp1 = 0 ;
6333 int res1 = 0 ;
6334 PyObject *swig_obj[1] ;
6335
6336 if (!args) SWIG_fail;
6337 swig_obj[0] = args;
6338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6339 if (!SWIG_IsOK(res1)) {
6340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6341 }
6342 arg1 = reinterpret_cast< wxRect * >(argp1);
6343 {
6344 PyThreadState* __tstate = wxPyBeginAllowThreads();
6345 result = (int)(arg1)->GetY();
6346 wxPyEndAllowThreads(__tstate);
6347 if (PyErr_Occurred()) SWIG_fail;
6348 }
6349 resultobj = SWIG_From_int(static_cast< int >(result));
6350 return resultobj;
6351 fail:
6352 return NULL;
6353 }
6354
6355
6356 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6357 PyObject *resultobj = 0;
6358 wxRect *arg1 = (wxRect *) 0 ;
6359 int arg2 ;
6360 void *argp1 = 0 ;
6361 int res1 = 0 ;
6362 int val2 ;
6363 int ecode2 = 0 ;
6364 PyObject * obj0 = 0 ;
6365 PyObject * obj1 = 0 ;
6366 char * kwnames[] = {
6367 (char *) "self",(char *) "y", NULL
6368 };
6369
6370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6372 if (!SWIG_IsOK(res1)) {
6373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6374 }
6375 arg1 = reinterpret_cast< wxRect * >(argp1);
6376 ecode2 = SWIG_AsVal_int(obj1, &val2);
6377 if (!SWIG_IsOK(ecode2)) {
6378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6379 }
6380 arg2 = static_cast< int >(val2);
6381 {
6382 PyThreadState* __tstate = wxPyBeginAllowThreads();
6383 (arg1)->SetY(arg2);
6384 wxPyEndAllowThreads(__tstate);
6385 if (PyErr_Occurred()) SWIG_fail;
6386 }
6387 resultobj = SWIG_Py_Void();
6388 return resultobj;
6389 fail:
6390 return NULL;
6391 }
6392
6393
6394 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6395 PyObject *resultobj = 0;
6396 wxRect *arg1 = (wxRect *) 0 ;
6397 int result;
6398 void *argp1 = 0 ;
6399 int res1 = 0 ;
6400 PyObject *swig_obj[1] ;
6401
6402 if (!args) SWIG_fail;
6403 swig_obj[0] = args;
6404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6405 if (!SWIG_IsOK(res1)) {
6406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6407 }
6408 arg1 = reinterpret_cast< wxRect * >(argp1);
6409 {
6410 PyThreadState* __tstate = wxPyBeginAllowThreads();
6411 result = (int)((wxRect const *)arg1)->GetWidth();
6412 wxPyEndAllowThreads(__tstate);
6413 if (PyErr_Occurred()) SWIG_fail;
6414 }
6415 resultobj = SWIG_From_int(static_cast< int >(result));
6416 return resultobj;
6417 fail:
6418 return NULL;
6419 }
6420
6421
6422 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6423 PyObject *resultobj = 0;
6424 wxRect *arg1 = (wxRect *) 0 ;
6425 int arg2 ;
6426 void *argp1 = 0 ;
6427 int res1 = 0 ;
6428 int val2 ;
6429 int ecode2 = 0 ;
6430 PyObject * obj0 = 0 ;
6431 PyObject * obj1 = 0 ;
6432 char * kwnames[] = {
6433 (char *) "self",(char *) "w", NULL
6434 };
6435
6436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6438 if (!SWIG_IsOK(res1)) {
6439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6440 }
6441 arg1 = reinterpret_cast< wxRect * >(argp1);
6442 ecode2 = SWIG_AsVal_int(obj1, &val2);
6443 if (!SWIG_IsOK(ecode2)) {
6444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6445 }
6446 arg2 = static_cast< int >(val2);
6447 {
6448 PyThreadState* __tstate = wxPyBeginAllowThreads();
6449 (arg1)->SetWidth(arg2);
6450 wxPyEndAllowThreads(__tstate);
6451 if (PyErr_Occurred()) SWIG_fail;
6452 }
6453 resultobj = SWIG_Py_Void();
6454 return resultobj;
6455 fail:
6456 return NULL;
6457 }
6458
6459
6460 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6461 PyObject *resultobj = 0;
6462 wxRect *arg1 = (wxRect *) 0 ;
6463 int result;
6464 void *argp1 = 0 ;
6465 int res1 = 0 ;
6466 PyObject *swig_obj[1] ;
6467
6468 if (!args) SWIG_fail;
6469 swig_obj[0] = args;
6470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6471 if (!SWIG_IsOK(res1)) {
6472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6473 }
6474 arg1 = reinterpret_cast< wxRect * >(argp1);
6475 {
6476 PyThreadState* __tstate = wxPyBeginAllowThreads();
6477 result = (int)((wxRect const *)arg1)->GetHeight();
6478 wxPyEndAllowThreads(__tstate);
6479 if (PyErr_Occurred()) SWIG_fail;
6480 }
6481 resultobj = SWIG_From_int(static_cast< int >(result));
6482 return resultobj;
6483 fail:
6484 return NULL;
6485 }
6486
6487
6488 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6489 PyObject *resultobj = 0;
6490 wxRect *arg1 = (wxRect *) 0 ;
6491 int arg2 ;
6492 void *argp1 = 0 ;
6493 int res1 = 0 ;
6494 int val2 ;
6495 int ecode2 = 0 ;
6496 PyObject * obj0 = 0 ;
6497 PyObject * obj1 = 0 ;
6498 char * kwnames[] = {
6499 (char *) "self",(char *) "h", NULL
6500 };
6501
6502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6504 if (!SWIG_IsOK(res1)) {
6505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6506 }
6507 arg1 = reinterpret_cast< wxRect * >(argp1);
6508 ecode2 = SWIG_AsVal_int(obj1, &val2);
6509 if (!SWIG_IsOK(ecode2)) {
6510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6511 }
6512 arg2 = static_cast< int >(val2);
6513 {
6514 PyThreadState* __tstate = wxPyBeginAllowThreads();
6515 (arg1)->SetHeight(arg2);
6516 wxPyEndAllowThreads(__tstate);
6517 if (PyErr_Occurred()) SWIG_fail;
6518 }
6519 resultobj = SWIG_Py_Void();
6520 return resultobj;
6521 fail:
6522 return NULL;
6523 }
6524
6525
6526 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6527 PyObject *resultobj = 0;
6528 wxRect *arg1 = (wxRect *) 0 ;
6529 wxPoint result;
6530 void *argp1 = 0 ;
6531 int res1 = 0 ;
6532 PyObject *swig_obj[1] ;
6533
6534 if (!args) SWIG_fail;
6535 swig_obj[0] = args;
6536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6537 if (!SWIG_IsOK(res1)) {
6538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6539 }
6540 arg1 = reinterpret_cast< wxRect * >(argp1);
6541 {
6542 PyThreadState* __tstate = wxPyBeginAllowThreads();
6543 result = ((wxRect const *)arg1)->GetPosition();
6544 wxPyEndAllowThreads(__tstate);
6545 if (PyErr_Occurred()) SWIG_fail;
6546 }
6547 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6548 return resultobj;
6549 fail:
6550 return NULL;
6551 }
6552
6553
6554 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6555 PyObject *resultobj = 0;
6556 wxRect *arg1 = (wxRect *) 0 ;
6557 wxPoint *arg2 = 0 ;
6558 void *argp1 = 0 ;
6559 int res1 = 0 ;
6560 wxPoint temp2 ;
6561 PyObject * obj0 = 0 ;
6562 PyObject * obj1 = 0 ;
6563 char * kwnames[] = {
6564 (char *) "self",(char *) "p", NULL
6565 };
6566
6567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6569 if (!SWIG_IsOK(res1)) {
6570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6571 }
6572 arg1 = reinterpret_cast< wxRect * >(argp1);
6573 {
6574 arg2 = &temp2;
6575 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6576 }
6577 {
6578 PyThreadState* __tstate = wxPyBeginAllowThreads();
6579 (arg1)->SetPosition((wxPoint const &)*arg2);
6580 wxPyEndAllowThreads(__tstate);
6581 if (PyErr_Occurred()) SWIG_fail;
6582 }
6583 resultobj = SWIG_Py_Void();
6584 return resultobj;
6585 fail:
6586 return NULL;
6587 }
6588
6589
6590 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6591 PyObject *resultobj = 0;
6592 wxRect *arg1 = (wxRect *) 0 ;
6593 wxSize result;
6594 void *argp1 = 0 ;
6595 int res1 = 0 ;
6596 PyObject *swig_obj[1] ;
6597
6598 if (!args) SWIG_fail;
6599 swig_obj[0] = args;
6600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6601 if (!SWIG_IsOK(res1)) {
6602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6603 }
6604 arg1 = reinterpret_cast< wxRect * >(argp1);
6605 {
6606 PyThreadState* __tstate = wxPyBeginAllowThreads();
6607 result = ((wxRect const *)arg1)->GetSize();
6608 wxPyEndAllowThreads(__tstate);
6609 if (PyErr_Occurred()) SWIG_fail;
6610 }
6611 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6612 return resultobj;
6613 fail:
6614 return NULL;
6615 }
6616
6617
6618 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6619 PyObject *resultobj = 0;
6620 wxRect *arg1 = (wxRect *) 0 ;
6621 wxSize *arg2 = 0 ;
6622 void *argp1 = 0 ;
6623 int res1 = 0 ;
6624 wxSize temp2 ;
6625 PyObject * obj0 = 0 ;
6626 PyObject * obj1 = 0 ;
6627 char * kwnames[] = {
6628 (char *) "self",(char *) "s", NULL
6629 };
6630
6631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6633 if (!SWIG_IsOK(res1)) {
6634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6635 }
6636 arg1 = reinterpret_cast< wxRect * >(argp1);
6637 {
6638 arg2 = &temp2;
6639 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6640 }
6641 {
6642 PyThreadState* __tstate = wxPyBeginAllowThreads();
6643 (arg1)->SetSize((wxSize const &)*arg2);
6644 wxPyEndAllowThreads(__tstate);
6645 if (PyErr_Occurred()) SWIG_fail;
6646 }
6647 resultobj = SWIG_Py_Void();
6648 return resultobj;
6649 fail:
6650 return NULL;
6651 }
6652
6653
6654 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6655 PyObject *resultobj = 0;
6656 wxRect *arg1 = (wxRect *) 0 ;
6657 bool result;
6658 void *argp1 = 0 ;
6659 int res1 = 0 ;
6660 PyObject *swig_obj[1] ;
6661
6662 if (!args) SWIG_fail;
6663 swig_obj[0] = args;
6664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6665 if (!SWIG_IsOK(res1)) {
6666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6667 }
6668 arg1 = reinterpret_cast< wxRect * >(argp1);
6669 {
6670 PyThreadState* __tstate = wxPyBeginAllowThreads();
6671 result = (bool)((wxRect const *)arg1)->IsEmpty();
6672 wxPyEndAllowThreads(__tstate);
6673 if (PyErr_Occurred()) SWIG_fail;
6674 }
6675 {
6676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6677 }
6678 return resultobj;
6679 fail:
6680 return NULL;
6681 }
6682
6683
6684 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6685 PyObject *resultobj = 0;
6686 wxRect *arg1 = (wxRect *) 0 ;
6687 wxPoint result;
6688 void *argp1 = 0 ;
6689 int res1 = 0 ;
6690 PyObject *swig_obj[1] ;
6691
6692 if (!args) SWIG_fail;
6693 swig_obj[0] = args;
6694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6695 if (!SWIG_IsOK(res1)) {
6696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6697 }
6698 arg1 = reinterpret_cast< wxRect * >(argp1);
6699 {
6700 PyThreadState* __tstate = wxPyBeginAllowThreads();
6701 result = ((wxRect const *)arg1)->GetTopLeft();
6702 wxPyEndAllowThreads(__tstate);
6703 if (PyErr_Occurred()) SWIG_fail;
6704 }
6705 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6706 return resultobj;
6707 fail:
6708 return NULL;
6709 }
6710
6711
6712 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6713 PyObject *resultobj = 0;
6714 wxRect *arg1 = (wxRect *) 0 ;
6715 wxPoint *arg2 = 0 ;
6716 void *argp1 = 0 ;
6717 int res1 = 0 ;
6718 wxPoint temp2 ;
6719 PyObject * obj0 = 0 ;
6720 PyObject * obj1 = 0 ;
6721 char * kwnames[] = {
6722 (char *) "self",(char *) "p", NULL
6723 };
6724
6725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6727 if (!SWIG_IsOK(res1)) {
6728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6729 }
6730 arg1 = reinterpret_cast< wxRect * >(argp1);
6731 {
6732 arg2 = &temp2;
6733 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6734 }
6735 {
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6738 wxPyEndAllowThreads(__tstate);
6739 if (PyErr_Occurred()) SWIG_fail;
6740 }
6741 resultobj = SWIG_Py_Void();
6742 return resultobj;
6743 fail:
6744 return NULL;
6745 }
6746
6747
6748 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6749 PyObject *resultobj = 0;
6750 wxRect *arg1 = (wxRect *) 0 ;
6751 wxPoint result;
6752 void *argp1 = 0 ;
6753 int res1 = 0 ;
6754 PyObject *swig_obj[1] ;
6755
6756 if (!args) SWIG_fail;
6757 swig_obj[0] = args;
6758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6759 if (!SWIG_IsOK(res1)) {
6760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6761 }
6762 arg1 = reinterpret_cast< wxRect * >(argp1);
6763 {
6764 PyThreadState* __tstate = wxPyBeginAllowThreads();
6765 result = ((wxRect const *)arg1)->GetBottomRight();
6766 wxPyEndAllowThreads(__tstate);
6767 if (PyErr_Occurred()) SWIG_fail;
6768 }
6769 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6770 return resultobj;
6771 fail:
6772 return NULL;
6773 }
6774
6775
6776 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6777 PyObject *resultobj = 0;
6778 wxRect *arg1 = (wxRect *) 0 ;
6779 wxPoint *arg2 = 0 ;
6780 void *argp1 = 0 ;
6781 int res1 = 0 ;
6782 wxPoint temp2 ;
6783 PyObject * obj0 = 0 ;
6784 PyObject * obj1 = 0 ;
6785 char * kwnames[] = {
6786 (char *) "self",(char *) "p", NULL
6787 };
6788
6789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6791 if (!SWIG_IsOK(res1)) {
6792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6793 }
6794 arg1 = reinterpret_cast< wxRect * >(argp1);
6795 {
6796 arg2 = &temp2;
6797 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6798 }
6799 {
6800 PyThreadState* __tstate = wxPyBeginAllowThreads();
6801 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6802 wxPyEndAllowThreads(__tstate);
6803 if (PyErr_Occurred()) SWIG_fail;
6804 }
6805 resultobj = SWIG_Py_Void();
6806 return resultobj;
6807 fail:
6808 return NULL;
6809 }
6810
6811
6812 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6813 PyObject *resultobj = 0;
6814 wxRect *arg1 = (wxRect *) 0 ;
6815 int result;
6816 void *argp1 = 0 ;
6817 int res1 = 0 ;
6818 PyObject *swig_obj[1] ;
6819
6820 if (!args) SWIG_fail;
6821 swig_obj[0] = args;
6822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6823 if (!SWIG_IsOK(res1)) {
6824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6825 }
6826 arg1 = reinterpret_cast< wxRect * >(argp1);
6827 {
6828 PyThreadState* __tstate = wxPyBeginAllowThreads();
6829 result = (int)((wxRect const *)arg1)->GetLeft();
6830 wxPyEndAllowThreads(__tstate);
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 resultobj = SWIG_From_int(static_cast< int >(result));
6834 return resultobj;
6835 fail:
6836 return NULL;
6837 }
6838
6839
6840 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6841 PyObject *resultobj = 0;
6842 wxRect *arg1 = (wxRect *) 0 ;
6843 int result;
6844 void *argp1 = 0 ;
6845 int res1 = 0 ;
6846 PyObject *swig_obj[1] ;
6847
6848 if (!args) SWIG_fail;
6849 swig_obj[0] = args;
6850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6851 if (!SWIG_IsOK(res1)) {
6852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6853 }
6854 arg1 = reinterpret_cast< wxRect * >(argp1);
6855 {
6856 PyThreadState* __tstate = wxPyBeginAllowThreads();
6857 result = (int)((wxRect const *)arg1)->GetTop();
6858 wxPyEndAllowThreads(__tstate);
6859 if (PyErr_Occurred()) SWIG_fail;
6860 }
6861 resultobj = SWIG_From_int(static_cast< int >(result));
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6869 PyObject *resultobj = 0;
6870 wxRect *arg1 = (wxRect *) 0 ;
6871 int result;
6872 void *argp1 = 0 ;
6873 int res1 = 0 ;
6874 PyObject *swig_obj[1] ;
6875
6876 if (!args) SWIG_fail;
6877 swig_obj[0] = args;
6878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6879 if (!SWIG_IsOK(res1)) {
6880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6881 }
6882 arg1 = reinterpret_cast< wxRect * >(argp1);
6883 {
6884 PyThreadState* __tstate = wxPyBeginAllowThreads();
6885 result = (int)((wxRect const *)arg1)->GetBottom();
6886 wxPyEndAllowThreads(__tstate);
6887 if (PyErr_Occurred()) SWIG_fail;
6888 }
6889 resultobj = SWIG_From_int(static_cast< int >(result));
6890 return resultobj;
6891 fail:
6892 return NULL;
6893 }
6894
6895
6896 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6897 PyObject *resultobj = 0;
6898 wxRect *arg1 = (wxRect *) 0 ;
6899 int result;
6900 void *argp1 = 0 ;
6901 int res1 = 0 ;
6902 PyObject *swig_obj[1] ;
6903
6904 if (!args) SWIG_fail;
6905 swig_obj[0] = args;
6906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6907 if (!SWIG_IsOK(res1)) {
6908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6909 }
6910 arg1 = reinterpret_cast< wxRect * >(argp1);
6911 {
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 result = (int)((wxRect const *)arg1)->GetRight();
6914 wxPyEndAllowThreads(__tstate);
6915 if (PyErr_Occurred()) SWIG_fail;
6916 }
6917 resultobj = SWIG_From_int(static_cast< int >(result));
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6925 PyObject *resultobj = 0;
6926 wxRect *arg1 = (wxRect *) 0 ;
6927 int arg2 ;
6928 void *argp1 = 0 ;
6929 int res1 = 0 ;
6930 int val2 ;
6931 int ecode2 = 0 ;
6932 PyObject * obj0 = 0 ;
6933 PyObject * obj1 = 0 ;
6934 char * kwnames[] = {
6935 (char *) "self",(char *) "left", NULL
6936 };
6937
6938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6940 if (!SWIG_IsOK(res1)) {
6941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6942 }
6943 arg1 = reinterpret_cast< wxRect * >(argp1);
6944 ecode2 = SWIG_AsVal_int(obj1, &val2);
6945 if (!SWIG_IsOK(ecode2)) {
6946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6947 }
6948 arg2 = static_cast< int >(val2);
6949 {
6950 PyThreadState* __tstate = wxPyBeginAllowThreads();
6951 (arg1)->SetLeft(arg2);
6952 wxPyEndAllowThreads(__tstate);
6953 if (PyErr_Occurred()) SWIG_fail;
6954 }
6955 resultobj = SWIG_Py_Void();
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6963 PyObject *resultobj = 0;
6964 wxRect *arg1 = (wxRect *) 0 ;
6965 int arg2 ;
6966 void *argp1 = 0 ;
6967 int res1 = 0 ;
6968 int val2 ;
6969 int ecode2 = 0 ;
6970 PyObject * obj0 = 0 ;
6971 PyObject * obj1 = 0 ;
6972 char * kwnames[] = {
6973 (char *) "self",(char *) "right", NULL
6974 };
6975
6976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) 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_SetRight" "', 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_SetRight" "', expected argument " "2"" of type '" "int""'");
6985 }
6986 arg2 = static_cast< int >(val2);
6987 {
6988 PyThreadState* __tstate = wxPyBeginAllowThreads();
6989 (arg1)->SetRight(arg2);
6990 wxPyEndAllowThreads(__tstate);
6991 if (PyErr_Occurred()) SWIG_fail;
6992 }
6993 resultobj = SWIG_Py_Void();
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7001 PyObject *resultobj = 0;
7002 wxRect *arg1 = (wxRect *) 0 ;
7003 int arg2 ;
7004 void *argp1 = 0 ;
7005 int res1 = 0 ;
7006 int val2 ;
7007 int ecode2 = 0 ;
7008 PyObject * obj0 = 0 ;
7009 PyObject * obj1 = 0 ;
7010 char * kwnames[] = {
7011 (char *) "self",(char *) "top", NULL
7012 };
7013
7014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7016 if (!SWIG_IsOK(res1)) {
7017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7018 }
7019 arg1 = reinterpret_cast< wxRect * >(argp1);
7020 ecode2 = SWIG_AsVal_int(obj1, &val2);
7021 if (!SWIG_IsOK(ecode2)) {
7022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7023 }
7024 arg2 = static_cast< int >(val2);
7025 {
7026 PyThreadState* __tstate = wxPyBeginAllowThreads();
7027 (arg1)->SetTop(arg2);
7028 wxPyEndAllowThreads(__tstate);
7029 if (PyErr_Occurred()) SWIG_fail;
7030 }
7031 resultobj = SWIG_Py_Void();
7032 return resultobj;
7033 fail:
7034 return NULL;
7035 }
7036
7037
7038 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7039 PyObject *resultobj = 0;
7040 wxRect *arg1 = (wxRect *) 0 ;
7041 int arg2 ;
7042 void *argp1 = 0 ;
7043 int res1 = 0 ;
7044 int val2 ;
7045 int ecode2 = 0 ;
7046 PyObject * obj0 = 0 ;
7047 PyObject * obj1 = 0 ;
7048 char * kwnames[] = {
7049 (char *) "self",(char *) "bottom", NULL
7050 };
7051
7052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7054 if (!SWIG_IsOK(res1)) {
7055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7056 }
7057 arg1 = reinterpret_cast< wxRect * >(argp1);
7058 ecode2 = SWIG_AsVal_int(obj1, &val2);
7059 if (!SWIG_IsOK(ecode2)) {
7060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7061 }
7062 arg2 = static_cast< int >(val2);
7063 {
7064 PyThreadState* __tstate = wxPyBeginAllowThreads();
7065 (arg1)->SetBottom(arg2);
7066 wxPyEndAllowThreads(__tstate);
7067 if (PyErr_Occurred()) SWIG_fail;
7068 }
7069 resultobj = SWIG_Py_Void();
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7077 PyObject *resultobj = 0;
7078 wxRect *arg1 = (wxRect *) 0 ;
7079 int arg2 ;
7080 int arg3 ;
7081 wxRect *result = 0 ;
7082 void *argp1 = 0 ;
7083 int res1 = 0 ;
7084 int val2 ;
7085 int ecode2 = 0 ;
7086 int val3 ;
7087 int ecode3 = 0 ;
7088 PyObject * obj0 = 0 ;
7089 PyObject * obj1 = 0 ;
7090 PyObject * obj2 = 0 ;
7091 char * kwnames[] = {
7092 (char *) "self",(char *) "dx",(char *) "dy", NULL
7093 };
7094
7095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7097 if (!SWIG_IsOK(res1)) {
7098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7099 }
7100 arg1 = reinterpret_cast< wxRect * >(argp1);
7101 ecode2 = SWIG_AsVal_int(obj1, &val2);
7102 if (!SWIG_IsOK(ecode2)) {
7103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7104 }
7105 arg2 = static_cast< int >(val2);
7106 ecode3 = SWIG_AsVal_int(obj2, &val3);
7107 if (!SWIG_IsOK(ecode3)) {
7108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7109 }
7110 arg3 = static_cast< int >(val3);
7111 {
7112 PyThreadState* __tstate = wxPyBeginAllowThreads();
7113 {
7114 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7115 result = (wxRect *) &_result_ref;
7116 }
7117 wxPyEndAllowThreads(__tstate);
7118 if (PyErr_Occurred()) SWIG_fail;
7119 }
7120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7121 return resultobj;
7122 fail:
7123 return NULL;
7124 }
7125
7126
7127 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7128 PyObject *resultobj = 0;
7129 wxRect *arg1 = (wxRect *) 0 ;
7130 int arg2 ;
7131 int arg3 ;
7132 wxRect *result = 0 ;
7133 void *argp1 = 0 ;
7134 int res1 = 0 ;
7135 int val2 ;
7136 int ecode2 = 0 ;
7137 int val3 ;
7138 int ecode3 = 0 ;
7139 PyObject * obj0 = 0 ;
7140 PyObject * obj1 = 0 ;
7141 PyObject * obj2 = 0 ;
7142 char * kwnames[] = {
7143 (char *) "self",(char *) "dx",(char *) "dy", NULL
7144 };
7145
7146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7148 if (!SWIG_IsOK(res1)) {
7149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7150 }
7151 arg1 = reinterpret_cast< wxRect * >(argp1);
7152 ecode2 = SWIG_AsVal_int(obj1, &val2);
7153 if (!SWIG_IsOK(ecode2)) {
7154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7155 }
7156 arg2 = static_cast< int >(val2);
7157 ecode3 = SWIG_AsVal_int(obj2, &val3);
7158 if (!SWIG_IsOK(ecode3)) {
7159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7160 }
7161 arg3 = static_cast< int >(val3);
7162 {
7163 PyThreadState* __tstate = wxPyBeginAllowThreads();
7164 {
7165 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7166 result = (wxRect *) &_result_ref;
7167 }
7168 wxPyEndAllowThreads(__tstate);
7169 if (PyErr_Occurred()) SWIG_fail;
7170 }
7171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7172 return resultobj;
7173 fail:
7174 return NULL;
7175 }
7176
7177
7178 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7179 PyObject *resultobj = 0;
7180 wxRect *arg1 = (wxRect *) 0 ;
7181 int arg2 ;
7182 int arg3 ;
7183 void *argp1 = 0 ;
7184 int res1 = 0 ;
7185 int val2 ;
7186 int ecode2 = 0 ;
7187 int val3 ;
7188 int ecode3 = 0 ;
7189 PyObject * obj0 = 0 ;
7190 PyObject * obj1 = 0 ;
7191 PyObject * obj2 = 0 ;
7192 char * kwnames[] = {
7193 (char *) "self",(char *) "dx",(char *) "dy", NULL
7194 };
7195
7196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7198 if (!SWIG_IsOK(res1)) {
7199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7200 }
7201 arg1 = reinterpret_cast< wxRect * >(argp1);
7202 ecode2 = SWIG_AsVal_int(obj1, &val2);
7203 if (!SWIG_IsOK(ecode2)) {
7204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7205 }
7206 arg2 = static_cast< int >(val2);
7207 ecode3 = SWIG_AsVal_int(obj2, &val3);
7208 if (!SWIG_IsOK(ecode3)) {
7209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7210 }
7211 arg3 = static_cast< int >(val3);
7212 {
7213 PyThreadState* __tstate = wxPyBeginAllowThreads();
7214 (arg1)->Offset(arg2,arg3);
7215 wxPyEndAllowThreads(__tstate);
7216 if (PyErr_Occurred()) SWIG_fail;
7217 }
7218 resultobj = SWIG_Py_Void();
7219 return resultobj;
7220 fail:
7221 return NULL;
7222 }
7223
7224
7225 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7226 PyObject *resultobj = 0;
7227 wxRect *arg1 = (wxRect *) 0 ;
7228 wxPoint *arg2 = 0 ;
7229 void *argp1 = 0 ;
7230 int res1 = 0 ;
7231 wxPoint temp2 ;
7232 PyObject * obj0 = 0 ;
7233 PyObject * obj1 = 0 ;
7234 char * kwnames[] = {
7235 (char *) "self",(char *) "pt", NULL
7236 };
7237
7238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7242 }
7243 arg1 = reinterpret_cast< wxRect * >(argp1);
7244 {
7245 arg2 = &temp2;
7246 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7247 }
7248 {
7249 PyThreadState* __tstate = wxPyBeginAllowThreads();
7250 (arg1)->Offset((wxPoint const &)*arg2);
7251 wxPyEndAllowThreads(__tstate);
7252 if (PyErr_Occurred()) SWIG_fail;
7253 }
7254 resultobj = SWIG_Py_Void();
7255 return resultobj;
7256 fail:
7257 return NULL;
7258 }
7259
7260
7261 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7262 PyObject *resultobj = 0;
7263 wxRect *arg1 = (wxRect *) 0 ;
7264 wxRect *arg2 = 0 ;
7265 wxRect result;
7266 void *argp1 = 0 ;
7267 int res1 = 0 ;
7268 wxRect temp2 ;
7269 PyObject * obj0 = 0 ;
7270 PyObject * obj1 = 0 ;
7271 char * kwnames[] = {
7272 (char *) "self",(char *) "rect", NULL
7273 };
7274
7275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7277 if (!SWIG_IsOK(res1)) {
7278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7279 }
7280 arg1 = reinterpret_cast< wxRect * >(argp1);
7281 {
7282 arg2 = &temp2;
7283 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7284 }
7285 {
7286 PyThreadState* __tstate = wxPyBeginAllowThreads();
7287 result = (arg1)->Intersect((wxRect const &)*arg2);
7288 wxPyEndAllowThreads(__tstate);
7289 if (PyErr_Occurred()) SWIG_fail;
7290 }
7291 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7292 return resultobj;
7293 fail:
7294 return NULL;
7295 }
7296
7297
7298 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7299 PyObject *resultobj = 0;
7300 wxRect *arg1 = (wxRect *) 0 ;
7301 wxRect *arg2 = 0 ;
7302 wxRect result;
7303 void *argp1 = 0 ;
7304 int res1 = 0 ;
7305 wxRect temp2 ;
7306 PyObject * obj0 = 0 ;
7307 PyObject * obj1 = 0 ;
7308 char * kwnames[] = {
7309 (char *) "self",(char *) "rect", NULL
7310 };
7311
7312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7314 if (!SWIG_IsOK(res1)) {
7315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7316 }
7317 arg1 = reinterpret_cast< wxRect * >(argp1);
7318 {
7319 arg2 = &temp2;
7320 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7321 }
7322 {
7323 PyThreadState* __tstate = wxPyBeginAllowThreads();
7324 result = (arg1)->Union((wxRect const &)*arg2);
7325 wxPyEndAllowThreads(__tstate);
7326 if (PyErr_Occurred()) SWIG_fail;
7327 }
7328 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7329 return resultobj;
7330 fail:
7331 return NULL;
7332 }
7333
7334
7335 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7336 PyObject *resultobj = 0;
7337 wxRect *arg1 = (wxRect *) 0 ;
7338 wxRect *arg2 = 0 ;
7339 wxRect result;
7340 void *argp1 = 0 ;
7341 int res1 = 0 ;
7342 wxRect temp2 ;
7343 PyObject * obj0 = 0 ;
7344 PyObject * obj1 = 0 ;
7345 char * kwnames[] = {
7346 (char *) "self",(char *) "rect", NULL
7347 };
7348
7349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7351 if (!SWIG_IsOK(res1)) {
7352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7353 }
7354 arg1 = reinterpret_cast< wxRect * >(argp1);
7355 {
7356 arg2 = &temp2;
7357 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7358 }
7359 {
7360 PyThreadState* __tstate = wxPyBeginAllowThreads();
7361 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7362 wxPyEndAllowThreads(__tstate);
7363 if (PyErr_Occurred()) SWIG_fail;
7364 }
7365 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7366 return resultobj;
7367 fail:
7368 return NULL;
7369 }
7370
7371
7372 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7373 PyObject *resultobj = 0;
7374 wxRect *arg1 = (wxRect *) 0 ;
7375 wxRect *arg2 = 0 ;
7376 wxRect *result = 0 ;
7377 void *argp1 = 0 ;
7378 int res1 = 0 ;
7379 wxRect temp2 ;
7380 PyObject * obj0 = 0 ;
7381 PyObject * obj1 = 0 ;
7382 char * kwnames[] = {
7383 (char *) "self",(char *) "rect", NULL
7384 };
7385
7386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7388 if (!SWIG_IsOK(res1)) {
7389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7390 }
7391 arg1 = reinterpret_cast< wxRect * >(argp1);
7392 {
7393 arg2 = &temp2;
7394 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7395 }
7396 {
7397 PyThreadState* __tstate = wxPyBeginAllowThreads();
7398 {
7399 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7400 result = (wxRect *) &_result_ref;
7401 }
7402 wxPyEndAllowThreads(__tstate);
7403 if (PyErr_Occurred()) SWIG_fail;
7404 }
7405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7406 return resultobj;
7407 fail:
7408 return NULL;
7409 }
7410
7411
7412 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7413 PyObject *resultobj = 0;
7414 wxRect *arg1 = (wxRect *) 0 ;
7415 PyObject *arg2 = (PyObject *) 0 ;
7416 bool result;
7417 void *argp1 = 0 ;
7418 int res1 = 0 ;
7419 PyObject * obj0 = 0 ;
7420 PyObject * obj1 = 0 ;
7421 char * kwnames[] = {
7422 (char *) "self",(char *) "other", NULL
7423 };
7424
7425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7427 if (!SWIG_IsOK(res1)) {
7428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7429 }
7430 arg1 = reinterpret_cast< wxRect * >(argp1);
7431 arg2 = obj1;
7432 {
7433 result = (bool)wxRect___eq__(arg1,arg2);
7434 if (PyErr_Occurred()) SWIG_fail;
7435 }
7436 {
7437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7438 }
7439 return resultobj;
7440 fail:
7441 return NULL;
7442 }
7443
7444
7445 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7446 PyObject *resultobj = 0;
7447 wxRect *arg1 = (wxRect *) 0 ;
7448 PyObject *arg2 = (PyObject *) 0 ;
7449 bool result;
7450 void *argp1 = 0 ;
7451 int res1 = 0 ;
7452 PyObject * obj0 = 0 ;
7453 PyObject * obj1 = 0 ;
7454 char * kwnames[] = {
7455 (char *) "self",(char *) "other", NULL
7456 };
7457
7458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7460 if (!SWIG_IsOK(res1)) {
7461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7462 }
7463 arg1 = reinterpret_cast< wxRect * >(argp1);
7464 arg2 = obj1;
7465 {
7466 result = (bool)wxRect___ne__(arg1,arg2);
7467 if (PyErr_Occurred()) SWIG_fail;
7468 }
7469 {
7470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7471 }
7472 return resultobj;
7473 fail:
7474 return NULL;
7475 }
7476
7477
7478 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7479 PyObject *resultobj = 0;
7480 wxRect *arg1 = (wxRect *) 0 ;
7481 int arg2 ;
7482 int arg3 ;
7483 bool result;
7484 void *argp1 = 0 ;
7485 int res1 = 0 ;
7486 int val2 ;
7487 int ecode2 = 0 ;
7488 int val3 ;
7489 int ecode3 = 0 ;
7490 PyObject * obj0 = 0 ;
7491 PyObject * obj1 = 0 ;
7492 PyObject * obj2 = 0 ;
7493 char * kwnames[] = {
7494 (char *) "self",(char *) "x",(char *) "y", NULL
7495 };
7496
7497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7499 if (!SWIG_IsOK(res1)) {
7500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7501 }
7502 arg1 = reinterpret_cast< wxRect * >(argp1);
7503 ecode2 = SWIG_AsVal_int(obj1, &val2);
7504 if (!SWIG_IsOK(ecode2)) {
7505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7506 }
7507 arg2 = static_cast< int >(val2);
7508 ecode3 = SWIG_AsVal_int(obj2, &val3);
7509 if (!SWIG_IsOK(ecode3)) {
7510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7511 }
7512 arg3 = static_cast< int >(val3);
7513 {
7514 PyThreadState* __tstate = wxPyBeginAllowThreads();
7515 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7516 wxPyEndAllowThreads(__tstate);
7517 if (PyErr_Occurred()) SWIG_fail;
7518 }
7519 {
7520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7521 }
7522 return resultobj;
7523 fail:
7524 return NULL;
7525 }
7526
7527
7528 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7529 PyObject *resultobj = 0;
7530 wxRect *arg1 = (wxRect *) 0 ;
7531 wxPoint *arg2 = 0 ;
7532 bool result;
7533 void *argp1 = 0 ;
7534 int res1 = 0 ;
7535 wxPoint temp2 ;
7536 PyObject * obj0 = 0 ;
7537 PyObject * obj1 = 0 ;
7538 char * kwnames[] = {
7539 (char *) "self",(char *) "pt", NULL
7540 };
7541
7542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7544 if (!SWIG_IsOK(res1)) {
7545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7546 }
7547 arg1 = reinterpret_cast< wxRect * >(argp1);
7548 {
7549 arg2 = &temp2;
7550 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7551 }
7552 {
7553 PyThreadState* __tstate = wxPyBeginAllowThreads();
7554 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7555 wxPyEndAllowThreads(__tstate);
7556 if (PyErr_Occurred()) SWIG_fail;
7557 }
7558 {
7559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7560 }
7561 return resultobj;
7562 fail:
7563 return NULL;
7564 }
7565
7566
7567 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7568 PyObject *resultobj = 0;
7569 wxRect *arg1 = (wxRect *) 0 ;
7570 wxRect *arg2 = 0 ;
7571 bool result;
7572 void *argp1 = 0 ;
7573 int res1 = 0 ;
7574 wxRect temp2 ;
7575 PyObject * obj0 = 0 ;
7576 PyObject * obj1 = 0 ;
7577 char * kwnames[] = {
7578 (char *) "self",(char *) "rect", NULL
7579 };
7580
7581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7583 if (!SWIG_IsOK(res1)) {
7584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7585 }
7586 arg1 = reinterpret_cast< wxRect * >(argp1);
7587 {
7588 arg2 = &temp2;
7589 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7590 }
7591 {
7592 PyThreadState* __tstate = wxPyBeginAllowThreads();
7593 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7594 wxPyEndAllowThreads(__tstate);
7595 if (PyErr_Occurred()) SWIG_fail;
7596 }
7597 {
7598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7599 }
7600 return resultobj;
7601 fail:
7602 return NULL;
7603 }
7604
7605
7606 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7607 PyObject *resultobj = 0;
7608 wxRect *arg1 = (wxRect *) 0 ;
7609 wxRect *arg2 = 0 ;
7610 bool result;
7611 void *argp1 = 0 ;
7612 int res1 = 0 ;
7613 wxRect temp2 ;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 char * kwnames[] = {
7617 (char *) "self",(char *) "rect", NULL
7618 };
7619
7620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7622 if (!SWIG_IsOK(res1)) {
7623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7624 }
7625 arg1 = reinterpret_cast< wxRect * >(argp1);
7626 {
7627 arg2 = &temp2;
7628 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7629 }
7630 {
7631 PyThreadState* __tstate = wxPyBeginAllowThreads();
7632 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7633 wxPyEndAllowThreads(__tstate);
7634 if (PyErr_Occurred()) SWIG_fail;
7635 }
7636 {
7637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7638 }
7639 return resultobj;
7640 fail:
7641 return NULL;
7642 }
7643
7644
7645 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7646 PyObject *resultobj = 0;
7647 wxRect *arg1 = (wxRect *) 0 ;
7648 wxRect *arg2 = 0 ;
7649 int arg3 = (int) wxBOTH ;
7650 wxRect result;
7651 void *argp1 = 0 ;
7652 int res1 = 0 ;
7653 wxRect temp2 ;
7654 int val3 ;
7655 int ecode3 = 0 ;
7656 PyObject * obj0 = 0 ;
7657 PyObject * obj1 = 0 ;
7658 PyObject * obj2 = 0 ;
7659 char * kwnames[] = {
7660 (char *) "self",(char *) "r",(char *) "dir", NULL
7661 };
7662
7663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7665 if (!SWIG_IsOK(res1)) {
7666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7667 }
7668 arg1 = reinterpret_cast< wxRect * >(argp1);
7669 {
7670 arg2 = &temp2;
7671 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7672 }
7673 if (obj2) {
7674 ecode3 = SWIG_AsVal_int(obj2, &val3);
7675 if (!SWIG_IsOK(ecode3)) {
7676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7677 }
7678 arg3 = static_cast< int >(val3);
7679 }
7680 {
7681 PyThreadState* __tstate = wxPyBeginAllowThreads();
7682 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7683 wxPyEndAllowThreads(__tstate);
7684 if (PyErr_Occurred()) SWIG_fail;
7685 }
7686 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7687 return resultobj;
7688 fail:
7689 return NULL;
7690 }
7691
7692
7693 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7694 PyObject *resultobj = 0;
7695 wxRect *arg1 = (wxRect *) 0 ;
7696 int arg2 ;
7697 void *argp1 = 0 ;
7698 int res1 = 0 ;
7699 int val2 ;
7700 int ecode2 = 0 ;
7701 PyObject *swig_obj[2] ;
7702
7703 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7705 if (!SWIG_IsOK(res1)) {
7706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7707 }
7708 arg1 = reinterpret_cast< wxRect * >(argp1);
7709 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7710 if (!SWIG_IsOK(ecode2)) {
7711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7712 }
7713 arg2 = static_cast< int >(val2);
7714 if (arg1) (arg1)->x = arg2;
7715
7716 resultobj = SWIG_Py_Void();
7717 return resultobj;
7718 fail:
7719 return NULL;
7720 }
7721
7722
7723 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7724 PyObject *resultobj = 0;
7725 wxRect *arg1 = (wxRect *) 0 ;
7726 int result;
7727 void *argp1 = 0 ;
7728 int res1 = 0 ;
7729 PyObject *swig_obj[1] ;
7730
7731 if (!args) SWIG_fail;
7732 swig_obj[0] = args;
7733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7734 if (!SWIG_IsOK(res1)) {
7735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7736 }
7737 arg1 = reinterpret_cast< wxRect * >(argp1);
7738 result = (int) ((arg1)->x);
7739 resultobj = SWIG_From_int(static_cast< int >(result));
7740 return resultobj;
7741 fail:
7742 return NULL;
7743 }
7744
7745
7746 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7747 PyObject *resultobj = 0;
7748 wxRect *arg1 = (wxRect *) 0 ;
7749 int arg2 ;
7750 void *argp1 = 0 ;
7751 int res1 = 0 ;
7752 int val2 ;
7753 int ecode2 = 0 ;
7754 PyObject *swig_obj[2] ;
7755
7756 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7758 if (!SWIG_IsOK(res1)) {
7759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7760 }
7761 arg1 = reinterpret_cast< wxRect * >(argp1);
7762 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7763 if (!SWIG_IsOK(ecode2)) {
7764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7765 }
7766 arg2 = static_cast< int >(val2);
7767 if (arg1) (arg1)->y = arg2;
7768
7769 resultobj = SWIG_Py_Void();
7770 return resultobj;
7771 fail:
7772 return NULL;
7773 }
7774
7775
7776 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7777 PyObject *resultobj = 0;
7778 wxRect *arg1 = (wxRect *) 0 ;
7779 int result;
7780 void *argp1 = 0 ;
7781 int res1 = 0 ;
7782 PyObject *swig_obj[1] ;
7783
7784 if (!args) SWIG_fail;
7785 swig_obj[0] = args;
7786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7787 if (!SWIG_IsOK(res1)) {
7788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7789 }
7790 arg1 = reinterpret_cast< wxRect * >(argp1);
7791 result = (int) ((arg1)->y);
7792 resultobj = SWIG_From_int(static_cast< int >(result));
7793 return resultobj;
7794 fail:
7795 return NULL;
7796 }
7797
7798
7799 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7800 PyObject *resultobj = 0;
7801 wxRect *arg1 = (wxRect *) 0 ;
7802 int arg2 ;
7803 void *argp1 = 0 ;
7804 int res1 = 0 ;
7805 int val2 ;
7806 int ecode2 = 0 ;
7807 PyObject *swig_obj[2] ;
7808
7809 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7811 if (!SWIG_IsOK(res1)) {
7812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7813 }
7814 arg1 = reinterpret_cast< wxRect * >(argp1);
7815 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7816 if (!SWIG_IsOK(ecode2)) {
7817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7818 }
7819 arg2 = static_cast< int >(val2);
7820 if (arg1) (arg1)->width = arg2;
7821
7822 resultobj = SWIG_Py_Void();
7823 return resultobj;
7824 fail:
7825 return NULL;
7826 }
7827
7828
7829 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7830 PyObject *resultobj = 0;
7831 wxRect *arg1 = (wxRect *) 0 ;
7832 int result;
7833 void *argp1 = 0 ;
7834 int res1 = 0 ;
7835 PyObject *swig_obj[1] ;
7836
7837 if (!args) SWIG_fail;
7838 swig_obj[0] = args;
7839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7840 if (!SWIG_IsOK(res1)) {
7841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7842 }
7843 arg1 = reinterpret_cast< wxRect * >(argp1);
7844 result = (int) ((arg1)->width);
7845 resultobj = SWIG_From_int(static_cast< int >(result));
7846 return resultobj;
7847 fail:
7848 return NULL;
7849 }
7850
7851
7852 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7853 PyObject *resultobj = 0;
7854 wxRect *arg1 = (wxRect *) 0 ;
7855 int arg2 ;
7856 void *argp1 = 0 ;
7857 int res1 = 0 ;
7858 int val2 ;
7859 int ecode2 = 0 ;
7860 PyObject *swig_obj[2] ;
7861
7862 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7864 if (!SWIG_IsOK(res1)) {
7865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7866 }
7867 arg1 = reinterpret_cast< wxRect * >(argp1);
7868 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7869 if (!SWIG_IsOK(ecode2)) {
7870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7871 }
7872 arg2 = static_cast< int >(val2);
7873 if (arg1) (arg1)->height = arg2;
7874
7875 resultobj = SWIG_Py_Void();
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7883 PyObject *resultobj = 0;
7884 wxRect *arg1 = (wxRect *) 0 ;
7885 int result;
7886 void *argp1 = 0 ;
7887 int res1 = 0 ;
7888 PyObject *swig_obj[1] ;
7889
7890 if (!args) SWIG_fail;
7891 swig_obj[0] = args;
7892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7893 if (!SWIG_IsOK(res1)) {
7894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7895 }
7896 arg1 = reinterpret_cast< wxRect * >(argp1);
7897 result = (int) ((arg1)->height);
7898 resultobj = SWIG_From_int(static_cast< int >(result));
7899 return resultobj;
7900 fail:
7901 return NULL;
7902 }
7903
7904
7905 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7906 PyObject *resultobj = 0;
7907 wxRect *arg1 = (wxRect *) 0 ;
7908 int arg2 = (int) 0 ;
7909 int arg3 = (int) 0 ;
7910 int arg4 = (int) 0 ;
7911 int arg5 = (int) 0 ;
7912 void *argp1 = 0 ;
7913 int res1 = 0 ;
7914 int val2 ;
7915 int ecode2 = 0 ;
7916 int val3 ;
7917 int ecode3 = 0 ;
7918 int val4 ;
7919 int ecode4 = 0 ;
7920 int val5 ;
7921 int ecode5 = 0 ;
7922 PyObject * obj0 = 0 ;
7923 PyObject * obj1 = 0 ;
7924 PyObject * obj2 = 0 ;
7925 PyObject * obj3 = 0 ;
7926 PyObject * obj4 = 0 ;
7927 char * kwnames[] = {
7928 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7929 };
7930
7931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7933 if (!SWIG_IsOK(res1)) {
7934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7935 }
7936 arg1 = reinterpret_cast< wxRect * >(argp1);
7937 if (obj1) {
7938 ecode2 = SWIG_AsVal_int(obj1, &val2);
7939 if (!SWIG_IsOK(ecode2)) {
7940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7941 }
7942 arg2 = static_cast< int >(val2);
7943 }
7944 if (obj2) {
7945 ecode3 = SWIG_AsVal_int(obj2, &val3);
7946 if (!SWIG_IsOK(ecode3)) {
7947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7948 }
7949 arg3 = static_cast< int >(val3);
7950 }
7951 if (obj3) {
7952 ecode4 = SWIG_AsVal_int(obj3, &val4);
7953 if (!SWIG_IsOK(ecode4)) {
7954 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7955 }
7956 arg4 = static_cast< int >(val4);
7957 }
7958 if (obj4) {
7959 ecode5 = SWIG_AsVal_int(obj4, &val5);
7960 if (!SWIG_IsOK(ecode5)) {
7961 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7962 }
7963 arg5 = static_cast< int >(val5);
7964 }
7965 {
7966 PyThreadState* __tstate = wxPyBeginAllowThreads();
7967 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7968 wxPyEndAllowThreads(__tstate);
7969 if (PyErr_Occurred()) SWIG_fail;
7970 }
7971 resultobj = SWIG_Py_Void();
7972 return resultobj;
7973 fail:
7974 return NULL;
7975 }
7976
7977
7978 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7979 PyObject *resultobj = 0;
7980 wxRect *arg1 = (wxRect *) 0 ;
7981 PyObject *result = 0 ;
7982 void *argp1 = 0 ;
7983 int res1 = 0 ;
7984 PyObject *swig_obj[1] ;
7985
7986 if (!args) SWIG_fail;
7987 swig_obj[0] = args;
7988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7989 if (!SWIG_IsOK(res1)) {
7990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7991 }
7992 arg1 = reinterpret_cast< wxRect * >(argp1);
7993 {
7994 PyThreadState* __tstate = wxPyBeginAllowThreads();
7995 result = (PyObject *)wxRect_Get(arg1);
7996 wxPyEndAllowThreads(__tstate);
7997 if (PyErr_Occurred()) SWIG_fail;
7998 }
7999 resultobj = result;
8000 return resultobj;
8001 fail:
8002 return NULL;
8003 }
8004
8005
8006 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8007 PyObject *obj;
8008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8009 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8010 return SWIG_Py_Void();
8011 }
8012
8013 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8014 return SWIG_Python_InitShadowInstance(args);
8015 }
8016
8017 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8018 PyObject *resultobj = 0;
8019 wxRect *arg1 = (wxRect *) 0 ;
8020 wxRect *arg2 = (wxRect *) 0 ;
8021 PyObject *result = 0 ;
8022 void *argp1 = 0 ;
8023 int res1 = 0 ;
8024 void *argp2 = 0 ;
8025 int res2 = 0 ;
8026 PyObject * obj0 = 0 ;
8027 PyObject * obj1 = 0 ;
8028 char * kwnames[] = {
8029 (char *) "r1",(char *) "r2", NULL
8030 };
8031
8032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8034 if (!SWIG_IsOK(res1)) {
8035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8036 }
8037 arg1 = reinterpret_cast< wxRect * >(argp1);
8038 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8039 if (!SWIG_IsOK(res2)) {
8040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8041 }
8042 arg2 = reinterpret_cast< wxRect * >(argp2);
8043 {
8044 if (!wxPyCheckForApp()) SWIG_fail;
8045 PyThreadState* __tstate = wxPyBeginAllowThreads();
8046 result = (PyObject *)wxIntersectRect(arg1,arg2);
8047 wxPyEndAllowThreads(__tstate);
8048 if (PyErr_Occurred()) SWIG_fail;
8049 }
8050 resultobj = result;
8051 return resultobj;
8052 fail:
8053 return NULL;
8054 }
8055
8056
8057 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj = 0;
8059 double arg1 = (double) 0.0 ;
8060 double arg2 = (double) 0.0 ;
8061 wxPoint2D *result = 0 ;
8062 double val1 ;
8063 int ecode1 = 0 ;
8064 double val2 ;
8065 int ecode2 = 0 ;
8066 PyObject * obj0 = 0 ;
8067 PyObject * obj1 = 0 ;
8068 char * kwnames[] = {
8069 (char *) "x",(char *) "y", NULL
8070 };
8071
8072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8073 if (obj0) {
8074 ecode1 = SWIG_AsVal_double(obj0, &val1);
8075 if (!SWIG_IsOK(ecode1)) {
8076 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8077 }
8078 arg1 = static_cast< double >(val1);
8079 }
8080 if (obj1) {
8081 ecode2 = SWIG_AsVal_double(obj1, &val2);
8082 if (!SWIG_IsOK(ecode2)) {
8083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8084 }
8085 arg2 = static_cast< double >(val2);
8086 }
8087 {
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8090 wxPyEndAllowThreads(__tstate);
8091 if (PyErr_Occurred()) SWIG_fail;
8092 }
8093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8094 return resultobj;
8095 fail:
8096 return NULL;
8097 }
8098
8099
8100 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8101 PyObject *resultobj = 0;
8102 wxPoint2D *arg1 = 0 ;
8103 wxPoint2D *result = 0 ;
8104 wxPoint2D temp1 ;
8105 PyObject * obj0 = 0 ;
8106 char * kwnames[] = {
8107 (char *) "pt", NULL
8108 };
8109
8110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8111 {
8112 arg1 = &temp1;
8113 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8114 }
8115 {
8116 PyThreadState* __tstate = wxPyBeginAllowThreads();
8117 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8118 wxPyEndAllowThreads(__tstate);
8119 if (PyErr_Occurred()) SWIG_fail;
8120 }
8121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8122 return resultobj;
8123 fail:
8124 return NULL;
8125 }
8126
8127
8128 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8129 PyObject *resultobj = 0;
8130 wxPoint *arg1 = 0 ;
8131 wxPoint2D *result = 0 ;
8132 wxPoint temp1 ;
8133 PyObject * obj0 = 0 ;
8134 char * kwnames[] = {
8135 (char *) "pt", NULL
8136 };
8137
8138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8139 {
8140 arg1 = &temp1;
8141 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8142 }
8143 {
8144 PyThreadState* __tstate = wxPyBeginAllowThreads();
8145 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8146 wxPyEndAllowThreads(__tstate);
8147 if (PyErr_Occurred()) SWIG_fail;
8148 }
8149 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8157 PyObject *resultobj = 0;
8158 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8159 int *arg2 = (int *) 0 ;
8160 int *arg3 = (int *) 0 ;
8161 void *argp1 = 0 ;
8162 int res1 = 0 ;
8163 int temp2 ;
8164 int res2 = SWIG_TMPOBJ ;
8165 int temp3 ;
8166 int res3 = SWIG_TMPOBJ ;
8167 PyObject *swig_obj[1] ;
8168
8169 arg2 = &temp2;
8170 arg3 = &temp3;
8171 if (!args) SWIG_fail;
8172 swig_obj[0] = args;
8173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8174 if (!SWIG_IsOK(res1)) {
8175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8176 }
8177 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8178 {
8179 PyThreadState* __tstate = wxPyBeginAllowThreads();
8180 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8181 wxPyEndAllowThreads(__tstate);
8182 if (PyErr_Occurred()) SWIG_fail;
8183 }
8184 resultobj = SWIG_Py_Void();
8185 if (SWIG_IsTmpObj(res2)) {
8186 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8187 } else {
8188 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8190 }
8191 if (SWIG_IsTmpObj(res3)) {
8192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8193 } else {
8194 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8196 }
8197 return resultobj;
8198 fail:
8199 return NULL;
8200 }
8201
8202
8203 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8204 PyObject *resultobj = 0;
8205 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8206 int *arg2 = (int *) 0 ;
8207 int *arg3 = (int *) 0 ;
8208 void *argp1 = 0 ;
8209 int res1 = 0 ;
8210 int temp2 ;
8211 int res2 = SWIG_TMPOBJ ;
8212 int temp3 ;
8213 int res3 = SWIG_TMPOBJ ;
8214 PyObject *swig_obj[1] ;
8215
8216 arg2 = &temp2;
8217 arg3 = &temp3;
8218 if (!args) SWIG_fail;
8219 swig_obj[0] = args;
8220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8221 if (!SWIG_IsOK(res1)) {
8222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8223 }
8224 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8225 {
8226 PyThreadState* __tstate = wxPyBeginAllowThreads();
8227 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8228 wxPyEndAllowThreads(__tstate);
8229 if (PyErr_Occurred()) SWIG_fail;
8230 }
8231 resultobj = SWIG_Py_Void();
8232 if (SWIG_IsTmpObj(res2)) {
8233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8234 } else {
8235 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8237 }
8238 if (SWIG_IsTmpObj(res3)) {
8239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8240 } else {
8241 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8243 }
8244 return resultobj;
8245 fail:
8246 return NULL;
8247 }
8248
8249
8250 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8251 PyObject *resultobj = 0;
8252 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8253 double result;
8254 void *argp1 = 0 ;
8255 int res1 = 0 ;
8256 PyObject *swig_obj[1] ;
8257
8258 if (!args) SWIG_fail;
8259 swig_obj[0] = args;
8260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8261 if (!SWIG_IsOK(res1)) {
8262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8263 }
8264 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8265 {
8266 PyThreadState* __tstate = wxPyBeginAllowThreads();
8267 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8268 wxPyEndAllowThreads(__tstate);
8269 if (PyErr_Occurred()) SWIG_fail;
8270 }
8271 resultobj = SWIG_From_double(static_cast< double >(result));
8272 return resultobj;
8273 fail:
8274 return NULL;
8275 }
8276
8277
8278 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8279 PyObject *resultobj = 0;
8280 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8281 double result;
8282 void *argp1 = 0 ;
8283 int res1 = 0 ;
8284 PyObject *swig_obj[1] ;
8285
8286 if (!args) SWIG_fail;
8287 swig_obj[0] = args;
8288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8289 if (!SWIG_IsOK(res1)) {
8290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8291 }
8292 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8293 {
8294 PyThreadState* __tstate = wxPyBeginAllowThreads();
8295 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8296 wxPyEndAllowThreads(__tstate);
8297 if (PyErr_Occurred()) SWIG_fail;
8298 }
8299 resultobj = SWIG_From_double(static_cast< double >(result));
8300 return resultobj;
8301 fail:
8302 return NULL;
8303 }
8304
8305
8306 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8307 PyObject *resultobj = 0;
8308 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8309 double arg2 ;
8310 void *argp1 = 0 ;
8311 int res1 = 0 ;
8312 double val2 ;
8313 int ecode2 = 0 ;
8314 PyObject * obj0 = 0 ;
8315 PyObject * obj1 = 0 ;
8316 char * kwnames[] = {
8317 (char *) "self",(char *) "length", NULL
8318 };
8319
8320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8322 if (!SWIG_IsOK(res1)) {
8323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8324 }
8325 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8326 ecode2 = SWIG_AsVal_double(obj1, &val2);
8327 if (!SWIG_IsOK(ecode2)) {
8328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8329 }
8330 arg2 = static_cast< double >(val2);
8331 {
8332 PyThreadState* __tstate = wxPyBeginAllowThreads();
8333 (arg1)->SetVectorLength(arg2);
8334 wxPyEndAllowThreads(__tstate);
8335 if (PyErr_Occurred()) SWIG_fail;
8336 }
8337 resultobj = SWIG_Py_Void();
8338 return resultobj;
8339 fail:
8340 return NULL;
8341 }
8342
8343
8344 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8345 PyObject *resultobj = 0;
8346 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8347 double arg2 ;
8348 void *argp1 = 0 ;
8349 int res1 = 0 ;
8350 double val2 ;
8351 int ecode2 = 0 ;
8352 PyObject * obj0 = 0 ;
8353 PyObject * obj1 = 0 ;
8354 char * kwnames[] = {
8355 (char *) "self",(char *) "degrees", NULL
8356 };
8357
8358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8360 if (!SWIG_IsOK(res1)) {
8361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8362 }
8363 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8364 ecode2 = SWIG_AsVal_double(obj1, &val2);
8365 if (!SWIG_IsOK(ecode2)) {
8366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8367 }
8368 arg2 = static_cast< double >(val2);
8369 {
8370 PyThreadState* __tstate = wxPyBeginAllowThreads();
8371 (arg1)->SetVectorAngle(arg2);
8372 wxPyEndAllowThreads(__tstate);
8373 if (PyErr_Occurred()) SWIG_fail;
8374 }
8375 resultobj = SWIG_Py_Void();
8376 return resultobj;
8377 fail:
8378 return NULL;
8379 }
8380
8381
8382 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8383 PyObject *resultobj = 0;
8384 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8385 wxPoint2D *arg2 = 0 ;
8386 double result;
8387 void *argp1 = 0 ;
8388 int res1 = 0 ;
8389 wxPoint2D temp2 ;
8390 PyObject * obj0 = 0 ;
8391 PyObject * obj1 = 0 ;
8392 char * kwnames[] = {
8393 (char *) "self",(char *) "pt", NULL
8394 };
8395
8396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8398 if (!SWIG_IsOK(res1)) {
8399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8400 }
8401 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8402 {
8403 arg2 = &temp2;
8404 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8405 }
8406 {
8407 PyThreadState* __tstate = wxPyBeginAllowThreads();
8408 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 resultobj = SWIG_From_double(static_cast< double >(result));
8413 return resultobj;
8414 fail:
8415 return NULL;
8416 }
8417
8418
8419 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8420 PyObject *resultobj = 0;
8421 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8422 wxPoint2D *arg2 = 0 ;
8423 double result;
8424 void *argp1 = 0 ;
8425 int res1 = 0 ;
8426 wxPoint2D temp2 ;
8427 PyObject * obj0 = 0 ;
8428 PyObject * obj1 = 0 ;
8429 char * kwnames[] = {
8430 (char *) "self",(char *) "pt", NULL
8431 };
8432
8433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8435 if (!SWIG_IsOK(res1)) {
8436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8437 }
8438 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8439 {
8440 arg2 = &temp2;
8441 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8442 }
8443 {
8444 PyThreadState* __tstate = wxPyBeginAllowThreads();
8445 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8446 wxPyEndAllowThreads(__tstate);
8447 if (PyErr_Occurred()) SWIG_fail;
8448 }
8449 resultobj = SWIG_From_double(static_cast< double >(result));
8450 return resultobj;
8451 fail:
8452 return NULL;
8453 }
8454
8455
8456 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8457 PyObject *resultobj = 0;
8458 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8459 wxPoint2D *arg2 = 0 ;
8460 double result;
8461 void *argp1 = 0 ;
8462 int res1 = 0 ;
8463 wxPoint2D temp2 ;
8464 PyObject * obj0 = 0 ;
8465 PyObject * obj1 = 0 ;
8466 char * kwnames[] = {
8467 (char *) "self",(char *) "vec", NULL
8468 };
8469
8470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8472 if (!SWIG_IsOK(res1)) {
8473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8474 }
8475 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8476 {
8477 arg2 = &temp2;
8478 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8479 }
8480 {
8481 PyThreadState* __tstate = wxPyBeginAllowThreads();
8482 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8483 wxPyEndAllowThreads(__tstate);
8484 if (PyErr_Occurred()) SWIG_fail;
8485 }
8486 resultobj = SWIG_From_double(static_cast< double >(result));
8487 return resultobj;
8488 fail:
8489 return NULL;
8490 }
8491
8492
8493 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8494 PyObject *resultobj = 0;
8495 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8496 wxPoint2D *arg2 = 0 ;
8497 double result;
8498 void *argp1 = 0 ;
8499 int res1 = 0 ;
8500 wxPoint2D temp2 ;
8501 PyObject * obj0 = 0 ;
8502 PyObject * obj1 = 0 ;
8503 char * kwnames[] = {
8504 (char *) "self",(char *) "vec", NULL
8505 };
8506
8507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8509 if (!SWIG_IsOK(res1)) {
8510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8511 }
8512 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8513 {
8514 arg2 = &temp2;
8515 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8516 }
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8520 wxPyEndAllowThreads(__tstate);
8521 if (PyErr_Occurred()) SWIG_fail;
8522 }
8523 resultobj = SWIG_From_double(static_cast< double >(result));
8524 return resultobj;
8525 fail:
8526 return NULL;
8527 }
8528
8529
8530 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8531 PyObject *resultobj = 0;
8532 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8533 wxPoint2D result;
8534 void *argp1 = 0 ;
8535 int res1 = 0 ;
8536 PyObject *swig_obj[1] ;
8537
8538 if (!args) SWIG_fail;
8539 swig_obj[0] = args;
8540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8541 if (!SWIG_IsOK(res1)) {
8542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8543 }
8544 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8545 {
8546 PyThreadState* __tstate = wxPyBeginAllowThreads();
8547 result = (arg1)->operator -();
8548 wxPyEndAllowThreads(__tstate);
8549 if (PyErr_Occurred()) SWIG_fail;
8550 }
8551 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8552 return resultobj;
8553 fail:
8554 return NULL;
8555 }
8556
8557
8558 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8559 PyObject *resultobj = 0;
8560 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8561 wxPoint2D *arg2 = 0 ;
8562 wxPoint2D *result = 0 ;
8563 void *argp1 = 0 ;
8564 int res1 = 0 ;
8565 wxPoint2D temp2 ;
8566 PyObject * obj0 = 0 ;
8567 PyObject * obj1 = 0 ;
8568 char * kwnames[] = {
8569 (char *) "self",(char *) "pt", NULL
8570 };
8571
8572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8574 if (!SWIG_IsOK(res1)) {
8575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8576 }
8577 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8578 {
8579 arg2 = &temp2;
8580 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8581 }
8582 {
8583 PyThreadState* __tstate = wxPyBeginAllowThreads();
8584 {
8585 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8586 result = (wxPoint2D *) &_result_ref;
8587 }
8588 wxPyEndAllowThreads(__tstate);
8589 if (PyErr_Occurred()) SWIG_fail;
8590 }
8591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8592 return resultobj;
8593 fail:
8594 return NULL;
8595 }
8596
8597
8598 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8599 PyObject *resultobj = 0;
8600 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8601 wxPoint2D *arg2 = 0 ;
8602 wxPoint2D *result = 0 ;
8603 void *argp1 = 0 ;
8604 int res1 = 0 ;
8605 wxPoint2D temp2 ;
8606 PyObject * obj0 = 0 ;
8607 PyObject * obj1 = 0 ;
8608 char * kwnames[] = {
8609 (char *) "self",(char *) "pt", NULL
8610 };
8611
8612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8614 if (!SWIG_IsOK(res1)) {
8615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8616 }
8617 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8618 {
8619 arg2 = &temp2;
8620 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8621 }
8622 {
8623 PyThreadState* __tstate = wxPyBeginAllowThreads();
8624 {
8625 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8626 result = (wxPoint2D *) &_result_ref;
8627 }
8628 wxPyEndAllowThreads(__tstate);
8629 if (PyErr_Occurred()) SWIG_fail;
8630 }
8631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8632 return resultobj;
8633 fail:
8634 return NULL;
8635 }
8636
8637
8638 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8639 PyObject *resultobj = 0;
8640 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8641 wxPoint2D *arg2 = 0 ;
8642 wxPoint2D *result = 0 ;
8643 void *argp1 = 0 ;
8644 int res1 = 0 ;
8645 wxPoint2D temp2 ;
8646 PyObject * obj0 = 0 ;
8647 PyObject * obj1 = 0 ;
8648 char * kwnames[] = {
8649 (char *) "self",(char *) "pt", NULL
8650 };
8651
8652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8654 if (!SWIG_IsOK(res1)) {
8655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8656 }
8657 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8658 {
8659 arg2 = &temp2;
8660 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8661 }
8662 {
8663 PyThreadState* __tstate = wxPyBeginAllowThreads();
8664 {
8665 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8666 result = (wxPoint2D *) &_result_ref;
8667 }
8668 wxPyEndAllowThreads(__tstate);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8679 PyObject *resultobj = 0;
8680 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8681 wxPoint2D *arg2 = 0 ;
8682 wxPoint2D *result = 0 ;
8683 void *argp1 = 0 ;
8684 int res1 = 0 ;
8685 wxPoint2D temp2 ;
8686 PyObject * obj0 = 0 ;
8687 PyObject * obj1 = 0 ;
8688 char * kwnames[] = {
8689 (char *) "self",(char *) "pt", NULL
8690 };
8691
8692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8694 if (!SWIG_IsOK(res1)) {
8695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8696 }
8697 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8698 {
8699 arg2 = &temp2;
8700 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8701 }
8702 {
8703 PyThreadState* __tstate = wxPyBeginAllowThreads();
8704 {
8705 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8706 result = (wxPoint2D *) &_result_ref;
8707 }
8708 wxPyEndAllowThreads(__tstate);
8709 if (PyErr_Occurred()) SWIG_fail;
8710 }
8711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8712 return resultobj;
8713 fail:
8714 return NULL;
8715 }
8716
8717
8718 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8719 PyObject *resultobj = 0;
8720 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8721 PyObject *arg2 = (PyObject *) 0 ;
8722 bool result;
8723 void *argp1 = 0 ;
8724 int res1 = 0 ;
8725 PyObject * obj0 = 0 ;
8726 PyObject * obj1 = 0 ;
8727 char * kwnames[] = {
8728 (char *) "self",(char *) "other", NULL
8729 };
8730
8731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8733 if (!SWIG_IsOK(res1)) {
8734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8735 }
8736 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8737 arg2 = obj1;
8738 {
8739 result = (bool)wxPoint2D___eq__(arg1,arg2);
8740 if (PyErr_Occurred()) SWIG_fail;
8741 }
8742 {
8743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8744 }
8745 return resultobj;
8746 fail:
8747 return NULL;
8748 }
8749
8750
8751 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8752 PyObject *resultobj = 0;
8753 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8754 PyObject *arg2 = (PyObject *) 0 ;
8755 bool result;
8756 void *argp1 = 0 ;
8757 int res1 = 0 ;
8758 PyObject * obj0 = 0 ;
8759 PyObject * obj1 = 0 ;
8760 char * kwnames[] = {
8761 (char *) "self",(char *) "other", NULL
8762 };
8763
8764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8766 if (!SWIG_IsOK(res1)) {
8767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8768 }
8769 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8770 arg2 = obj1;
8771 {
8772 result = (bool)wxPoint2D___ne__(arg1,arg2);
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 {
8776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8777 }
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8785 PyObject *resultobj = 0;
8786 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8787 double arg2 ;
8788 void *argp1 = 0 ;
8789 int res1 = 0 ;
8790 double val2 ;
8791 int ecode2 = 0 ;
8792 PyObject *swig_obj[2] ;
8793
8794 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8796 if (!SWIG_IsOK(res1)) {
8797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8798 }
8799 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8800 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8801 if (!SWIG_IsOK(ecode2)) {
8802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8803 }
8804 arg2 = static_cast< double >(val2);
8805 if (arg1) (arg1)->m_x = arg2;
8806
8807 resultobj = SWIG_Py_Void();
8808 return resultobj;
8809 fail:
8810 return NULL;
8811 }
8812
8813
8814 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8815 PyObject *resultobj = 0;
8816 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8817 double result;
8818 void *argp1 = 0 ;
8819 int res1 = 0 ;
8820 PyObject *swig_obj[1] ;
8821
8822 if (!args) SWIG_fail;
8823 swig_obj[0] = args;
8824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8825 if (!SWIG_IsOK(res1)) {
8826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8827 }
8828 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8829 result = (double) ((arg1)->m_x);
8830 resultobj = SWIG_From_double(static_cast< double >(result));
8831 return resultobj;
8832 fail:
8833 return NULL;
8834 }
8835
8836
8837 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8838 PyObject *resultobj = 0;
8839 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8840 double arg2 ;
8841 void *argp1 = 0 ;
8842 int res1 = 0 ;
8843 double val2 ;
8844 int ecode2 = 0 ;
8845 PyObject *swig_obj[2] ;
8846
8847 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8849 if (!SWIG_IsOK(res1)) {
8850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8851 }
8852 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8853 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8854 if (!SWIG_IsOK(ecode2)) {
8855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8856 }
8857 arg2 = static_cast< double >(val2);
8858 if (arg1) (arg1)->m_y = arg2;
8859
8860 resultobj = SWIG_Py_Void();
8861 return resultobj;
8862 fail:
8863 return NULL;
8864 }
8865
8866
8867 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8868 PyObject *resultobj = 0;
8869 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8870 double result;
8871 void *argp1 = 0 ;
8872 int res1 = 0 ;
8873 PyObject *swig_obj[1] ;
8874
8875 if (!args) SWIG_fail;
8876 swig_obj[0] = args;
8877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8878 if (!SWIG_IsOK(res1)) {
8879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8880 }
8881 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8882 result = (double) ((arg1)->m_y);
8883 resultobj = SWIG_From_double(static_cast< double >(result));
8884 return resultobj;
8885 fail:
8886 return NULL;
8887 }
8888
8889
8890 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8891 PyObject *resultobj = 0;
8892 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8893 double arg2 = (double) 0 ;
8894 double arg3 = (double) 0 ;
8895 void *argp1 = 0 ;
8896 int res1 = 0 ;
8897 double val2 ;
8898 int ecode2 = 0 ;
8899 double val3 ;
8900 int ecode3 = 0 ;
8901 PyObject * obj0 = 0 ;
8902 PyObject * obj1 = 0 ;
8903 PyObject * obj2 = 0 ;
8904 char * kwnames[] = {
8905 (char *) "self",(char *) "x",(char *) "y", NULL
8906 };
8907
8908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8910 if (!SWIG_IsOK(res1)) {
8911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8912 }
8913 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8914 if (obj1) {
8915 ecode2 = SWIG_AsVal_double(obj1, &val2);
8916 if (!SWIG_IsOK(ecode2)) {
8917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8918 }
8919 arg2 = static_cast< double >(val2);
8920 }
8921 if (obj2) {
8922 ecode3 = SWIG_AsVal_double(obj2, &val3);
8923 if (!SWIG_IsOK(ecode3)) {
8924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8925 }
8926 arg3 = static_cast< double >(val3);
8927 }
8928 {
8929 PyThreadState* __tstate = wxPyBeginAllowThreads();
8930 wxPoint2D_Set(arg1,arg2,arg3);
8931 wxPyEndAllowThreads(__tstate);
8932 if (PyErr_Occurred()) SWIG_fail;
8933 }
8934 resultobj = SWIG_Py_Void();
8935 return resultobj;
8936 fail:
8937 return NULL;
8938 }
8939
8940
8941 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8942 PyObject *resultobj = 0;
8943 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8944 PyObject *result = 0 ;
8945 void *argp1 = 0 ;
8946 int res1 = 0 ;
8947 PyObject *swig_obj[1] ;
8948
8949 if (!args) SWIG_fail;
8950 swig_obj[0] = args;
8951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8952 if (!SWIG_IsOK(res1)) {
8953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8954 }
8955 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8956 {
8957 PyThreadState* __tstate = wxPyBeginAllowThreads();
8958 result = (PyObject *)wxPoint2D_Get(arg1);
8959 wxPyEndAllowThreads(__tstate);
8960 if (PyErr_Occurred()) SWIG_fail;
8961 }
8962 resultobj = result;
8963 return resultobj;
8964 fail:
8965 return NULL;
8966 }
8967
8968
8969 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8970 PyObject *obj;
8971 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8972 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8973 return SWIG_Py_Void();
8974 }
8975
8976 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8977 return SWIG_Python_InitShadowInstance(args);
8978 }
8979
8980 SWIGINTERN int DefaultPosition_set(PyObject *) {
8981 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8982 return 1;
8983 }
8984
8985
8986 SWIGINTERN PyObject *DefaultPosition_get(void) {
8987 PyObject *pyobj = 0;
8988
8989 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8990 return pyobj;
8991 }
8992
8993
8994 SWIGINTERN int DefaultSize_set(PyObject *) {
8995 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8996 return 1;
8997 }
8998
8999
9000 SWIGINTERN PyObject *DefaultSize_get(void) {
9001 PyObject *pyobj = 0;
9002
9003 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9004 return pyobj;
9005 }
9006
9007
9008 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9009 PyObject *resultobj = 0;
9010 PyObject *arg1 = (PyObject *) 0 ;
9011 wxPyInputStream *result = 0 ;
9012 PyObject * obj0 = 0 ;
9013 char * kwnames[] = {
9014 (char *) "p", NULL
9015 };
9016
9017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9018 arg1 = obj0;
9019 {
9020 PyThreadState* __tstate = wxPyBeginAllowThreads();
9021 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9022 wxPyEndAllowThreads(__tstate);
9023 if (PyErr_Occurred()) SWIG_fail;
9024 }
9025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9026 return resultobj;
9027 fail:
9028 return NULL;
9029 }
9030
9031
9032 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9033 PyObject *resultobj = 0;
9034 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9035 void *argp1 = 0 ;
9036 int res1 = 0 ;
9037 PyObject *swig_obj[1] ;
9038
9039 if (!args) SWIG_fail;
9040 swig_obj[0] = args;
9041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9042 if (!SWIG_IsOK(res1)) {
9043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9044 }
9045 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9046 {
9047 PyThreadState* __tstate = wxPyBeginAllowThreads();
9048 delete arg1;
9049
9050 wxPyEndAllowThreads(__tstate);
9051 if (PyErr_Occurred()) SWIG_fail;
9052 }
9053 resultobj = SWIG_Py_Void();
9054 return resultobj;
9055 fail:
9056 return NULL;
9057 }
9058
9059
9060 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9061 PyObject *resultobj = 0;
9062 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9063 void *argp1 = 0 ;
9064 int res1 = 0 ;
9065 PyObject *swig_obj[1] ;
9066
9067 if (!args) SWIG_fail;
9068 swig_obj[0] = args;
9069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9070 if (!SWIG_IsOK(res1)) {
9071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9072 }
9073 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9074 {
9075 PyThreadState* __tstate = wxPyBeginAllowThreads();
9076 (arg1)->close();
9077 wxPyEndAllowThreads(__tstate);
9078 if (PyErr_Occurred()) SWIG_fail;
9079 }
9080 resultobj = SWIG_Py_Void();
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9088 PyObject *resultobj = 0;
9089 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9090 void *argp1 = 0 ;
9091 int res1 = 0 ;
9092 PyObject *swig_obj[1] ;
9093
9094 if (!args) SWIG_fail;
9095 swig_obj[0] = args;
9096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9097 if (!SWIG_IsOK(res1)) {
9098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9099 }
9100 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9101 {
9102 PyThreadState* __tstate = wxPyBeginAllowThreads();
9103 (arg1)->flush();
9104 wxPyEndAllowThreads(__tstate);
9105 if (PyErr_Occurred()) SWIG_fail;
9106 }
9107 resultobj = SWIG_Py_Void();
9108 return resultobj;
9109 fail:
9110 return NULL;
9111 }
9112
9113
9114 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9115 PyObject *resultobj = 0;
9116 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9117 bool result;
9118 void *argp1 = 0 ;
9119 int res1 = 0 ;
9120 PyObject *swig_obj[1] ;
9121
9122 if (!args) SWIG_fail;
9123 swig_obj[0] = args;
9124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9125 if (!SWIG_IsOK(res1)) {
9126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9127 }
9128 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9129 {
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 result = (bool)(arg1)->eof();
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 {
9136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9137 }
9138 return resultobj;
9139 fail:
9140 return NULL;
9141 }
9142
9143
9144 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9145 PyObject *resultobj = 0;
9146 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9147 int arg2 = (int) -1 ;
9148 PyObject *result = 0 ;
9149 void *argp1 = 0 ;
9150 int res1 = 0 ;
9151 int val2 ;
9152 int ecode2 = 0 ;
9153 PyObject * obj0 = 0 ;
9154 PyObject * obj1 = 0 ;
9155 char * kwnames[] = {
9156 (char *) "self",(char *) "size", NULL
9157 };
9158
9159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9161 if (!SWIG_IsOK(res1)) {
9162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9163 }
9164 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9165 if (obj1) {
9166 ecode2 = SWIG_AsVal_int(obj1, &val2);
9167 if (!SWIG_IsOK(ecode2)) {
9168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9169 }
9170 arg2 = static_cast< int >(val2);
9171 }
9172 {
9173 PyThreadState* __tstate = wxPyBeginAllowThreads();
9174 result = (PyObject *)(arg1)->read(arg2);
9175 wxPyEndAllowThreads(__tstate);
9176 if (PyErr_Occurred()) SWIG_fail;
9177 }
9178 resultobj = result;
9179 return resultobj;
9180 fail:
9181 return NULL;
9182 }
9183
9184
9185 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9186 PyObject *resultobj = 0;
9187 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9188 int arg2 = (int) -1 ;
9189 PyObject *result = 0 ;
9190 void *argp1 = 0 ;
9191 int res1 = 0 ;
9192 int val2 ;
9193 int ecode2 = 0 ;
9194 PyObject * obj0 = 0 ;
9195 PyObject * obj1 = 0 ;
9196 char * kwnames[] = {
9197 (char *) "self",(char *) "size", NULL
9198 };
9199
9200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9202 if (!SWIG_IsOK(res1)) {
9203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9204 }
9205 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9206 if (obj1) {
9207 ecode2 = SWIG_AsVal_int(obj1, &val2);
9208 if (!SWIG_IsOK(ecode2)) {
9209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9210 }
9211 arg2 = static_cast< int >(val2);
9212 }
9213 {
9214 PyThreadState* __tstate = wxPyBeginAllowThreads();
9215 result = (PyObject *)(arg1)->readline(arg2);
9216 wxPyEndAllowThreads(__tstate);
9217 if (PyErr_Occurred()) SWIG_fail;
9218 }
9219 resultobj = result;
9220 return resultobj;
9221 fail:
9222 return NULL;
9223 }
9224
9225
9226 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9227 PyObject *resultobj = 0;
9228 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9229 int arg2 = (int) -1 ;
9230 PyObject *result = 0 ;
9231 void *argp1 = 0 ;
9232 int res1 = 0 ;
9233 int val2 ;
9234 int ecode2 = 0 ;
9235 PyObject * obj0 = 0 ;
9236 PyObject * obj1 = 0 ;
9237 char * kwnames[] = {
9238 (char *) "self",(char *) "sizehint", NULL
9239 };
9240
9241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9243 if (!SWIG_IsOK(res1)) {
9244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9245 }
9246 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9247 if (obj1) {
9248 ecode2 = SWIG_AsVal_int(obj1, &val2);
9249 if (!SWIG_IsOK(ecode2)) {
9250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9251 }
9252 arg2 = static_cast< int >(val2);
9253 }
9254 {
9255 PyThreadState* __tstate = wxPyBeginAllowThreads();
9256 result = (PyObject *)(arg1)->readlines(arg2);
9257 wxPyEndAllowThreads(__tstate);
9258 if (PyErr_Occurred()) SWIG_fail;
9259 }
9260 resultobj = result;
9261 return resultobj;
9262 fail:
9263 return NULL;
9264 }
9265
9266
9267 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9268 PyObject *resultobj = 0;
9269 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9270 int arg2 ;
9271 int arg3 = (int) 0 ;
9272 void *argp1 = 0 ;
9273 int res1 = 0 ;
9274 int val2 ;
9275 int ecode2 = 0 ;
9276 int val3 ;
9277 int ecode3 = 0 ;
9278 PyObject * obj0 = 0 ;
9279 PyObject * obj1 = 0 ;
9280 PyObject * obj2 = 0 ;
9281 char * kwnames[] = {
9282 (char *) "self",(char *) "offset",(char *) "whence", NULL
9283 };
9284
9285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9287 if (!SWIG_IsOK(res1)) {
9288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9289 }
9290 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9291 ecode2 = SWIG_AsVal_int(obj1, &val2);
9292 if (!SWIG_IsOK(ecode2)) {
9293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9294 }
9295 arg2 = static_cast< int >(val2);
9296 if (obj2) {
9297 ecode3 = SWIG_AsVal_int(obj2, &val3);
9298 if (!SWIG_IsOK(ecode3)) {
9299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9300 }
9301 arg3 = static_cast< int >(val3);
9302 }
9303 {
9304 PyThreadState* __tstate = wxPyBeginAllowThreads();
9305 (arg1)->seek(arg2,arg3);
9306 wxPyEndAllowThreads(__tstate);
9307 if (PyErr_Occurred()) SWIG_fail;
9308 }
9309 resultobj = SWIG_Py_Void();
9310 return resultobj;
9311 fail:
9312 return NULL;
9313 }
9314
9315
9316 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9317 PyObject *resultobj = 0;
9318 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9319 int result;
9320 void *argp1 = 0 ;
9321 int res1 = 0 ;
9322 PyObject *swig_obj[1] ;
9323
9324 if (!args) SWIG_fail;
9325 swig_obj[0] = args;
9326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9327 if (!SWIG_IsOK(res1)) {
9328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9329 }
9330 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9331 {
9332 PyThreadState* __tstate = wxPyBeginAllowThreads();
9333 result = (int)(arg1)->tell();
9334 wxPyEndAllowThreads(__tstate);
9335 if (PyErr_Occurred()) SWIG_fail;
9336 }
9337 resultobj = SWIG_From_int(static_cast< int >(result));
9338 return resultobj;
9339 fail:
9340 return NULL;
9341 }
9342
9343
9344 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9345 PyObject *resultobj = 0;
9346 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9347 char result;
9348 void *argp1 = 0 ;
9349 int res1 = 0 ;
9350 PyObject *swig_obj[1] ;
9351
9352 if (!args) SWIG_fail;
9353 swig_obj[0] = args;
9354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9355 if (!SWIG_IsOK(res1)) {
9356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9357 }
9358 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9359 {
9360 PyThreadState* __tstate = wxPyBeginAllowThreads();
9361 result = (char)(arg1)->Peek();
9362 wxPyEndAllowThreads(__tstate);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 resultobj = SWIG_From_char(static_cast< char >(result));
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9373 PyObject *resultobj = 0;
9374 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9375 char result;
9376 void *argp1 = 0 ;
9377 int res1 = 0 ;
9378 PyObject *swig_obj[1] ;
9379
9380 if (!args) SWIG_fail;
9381 swig_obj[0] = args;
9382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9383 if (!SWIG_IsOK(res1)) {
9384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9385 }
9386 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9387 {
9388 PyThreadState* __tstate = wxPyBeginAllowThreads();
9389 result = (char)(arg1)->GetC();
9390 wxPyEndAllowThreads(__tstate);
9391 if (PyErr_Occurred()) SWIG_fail;
9392 }
9393 resultobj = SWIG_From_char(static_cast< char >(result));
9394 return resultobj;
9395 fail:
9396 return NULL;
9397 }
9398
9399
9400 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9401 PyObject *resultobj = 0;
9402 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9403 size_t result;
9404 void *argp1 = 0 ;
9405 int res1 = 0 ;
9406 PyObject *swig_obj[1] ;
9407
9408 if (!args) SWIG_fail;
9409 swig_obj[0] = args;
9410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9411 if (!SWIG_IsOK(res1)) {
9412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9413 }
9414 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9415 {
9416 PyThreadState* __tstate = wxPyBeginAllowThreads();
9417 result = (size_t)(arg1)->LastRead();
9418 wxPyEndAllowThreads(__tstate);
9419 if (PyErr_Occurred()) SWIG_fail;
9420 }
9421 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9422 return resultobj;
9423 fail:
9424 return NULL;
9425 }
9426
9427
9428 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9429 PyObject *resultobj = 0;
9430 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9431 bool result;
9432 void *argp1 = 0 ;
9433 int res1 = 0 ;
9434 PyObject *swig_obj[1] ;
9435
9436 if (!args) SWIG_fail;
9437 swig_obj[0] = args;
9438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9439 if (!SWIG_IsOK(res1)) {
9440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9441 }
9442 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9443 {
9444 PyThreadState* __tstate = wxPyBeginAllowThreads();
9445 result = (bool)(arg1)->CanRead();
9446 wxPyEndAllowThreads(__tstate);
9447 if (PyErr_Occurred()) SWIG_fail;
9448 }
9449 {
9450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9451 }
9452 return resultobj;
9453 fail:
9454 return NULL;
9455 }
9456
9457
9458 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9459 PyObject *resultobj = 0;
9460 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9461 bool result;
9462 void *argp1 = 0 ;
9463 int res1 = 0 ;
9464 PyObject *swig_obj[1] ;
9465
9466 if (!args) SWIG_fail;
9467 swig_obj[0] = args;
9468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9469 if (!SWIG_IsOK(res1)) {
9470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9471 }
9472 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9473 {
9474 PyThreadState* __tstate = wxPyBeginAllowThreads();
9475 result = (bool)(arg1)->Eof();
9476 wxPyEndAllowThreads(__tstate);
9477 if (PyErr_Occurred()) SWIG_fail;
9478 }
9479 {
9480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9481 }
9482 return resultobj;
9483 fail:
9484 return NULL;
9485 }
9486
9487
9488 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9489 PyObject *resultobj = 0;
9490 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9491 char arg2 ;
9492 bool result;
9493 void *argp1 = 0 ;
9494 int res1 = 0 ;
9495 char val2 ;
9496 int ecode2 = 0 ;
9497 PyObject * obj0 = 0 ;
9498 PyObject * obj1 = 0 ;
9499 char * kwnames[] = {
9500 (char *) "self",(char *) "c", NULL
9501 };
9502
9503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9505 if (!SWIG_IsOK(res1)) {
9506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9507 }
9508 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9509 ecode2 = SWIG_AsVal_char(obj1, &val2);
9510 if (!SWIG_IsOK(ecode2)) {
9511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9512 }
9513 arg2 = static_cast< char >(val2);
9514 {
9515 PyThreadState* __tstate = wxPyBeginAllowThreads();
9516 result = (bool)(arg1)->Ungetch(arg2);
9517 wxPyEndAllowThreads(__tstate);
9518 if (PyErr_Occurred()) SWIG_fail;
9519 }
9520 {
9521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9522 }
9523 return resultobj;
9524 fail:
9525 return NULL;
9526 }
9527
9528
9529 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9530 PyObject *resultobj = 0;
9531 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9532 long arg2 ;
9533 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9534 long result;
9535 void *argp1 = 0 ;
9536 int res1 = 0 ;
9537 long val2 ;
9538 int ecode2 = 0 ;
9539 int val3 ;
9540 int ecode3 = 0 ;
9541 PyObject * obj0 = 0 ;
9542 PyObject * obj1 = 0 ;
9543 PyObject * obj2 = 0 ;
9544 char * kwnames[] = {
9545 (char *) "self",(char *) "pos",(char *) "mode", NULL
9546 };
9547
9548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9550 if (!SWIG_IsOK(res1)) {
9551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9552 }
9553 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9554 ecode2 = SWIG_AsVal_long(obj1, &val2);
9555 if (!SWIG_IsOK(ecode2)) {
9556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9557 }
9558 arg2 = static_cast< long >(val2);
9559 if (obj2) {
9560 ecode3 = SWIG_AsVal_int(obj2, &val3);
9561 if (!SWIG_IsOK(ecode3)) {
9562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9563 }
9564 arg3 = static_cast< wxSeekMode >(val3);
9565 }
9566 {
9567 PyThreadState* __tstate = wxPyBeginAllowThreads();
9568 result = (long)(arg1)->SeekI(arg2,arg3);
9569 wxPyEndAllowThreads(__tstate);
9570 if (PyErr_Occurred()) SWIG_fail;
9571 }
9572 resultobj = SWIG_From_long(static_cast< long >(result));
9573 return resultobj;
9574 fail:
9575 return NULL;
9576 }
9577
9578
9579 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9580 PyObject *resultobj = 0;
9581 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9582 long result;
9583 void *argp1 = 0 ;
9584 int res1 = 0 ;
9585 PyObject *swig_obj[1] ;
9586
9587 if (!args) SWIG_fail;
9588 swig_obj[0] = args;
9589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9590 if (!SWIG_IsOK(res1)) {
9591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9592 }
9593 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9594 {
9595 PyThreadState* __tstate = wxPyBeginAllowThreads();
9596 result = (long)(arg1)->TellI();
9597 wxPyEndAllowThreads(__tstate);
9598 if (PyErr_Occurred()) SWIG_fail;
9599 }
9600 resultobj = SWIG_From_long(static_cast< long >(result));
9601 return resultobj;
9602 fail:
9603 return NULL;
9604 }
9605
9606
9607 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9608 PyObject *obj;
9609 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9610 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9611 return SWIG_Py_Void();
9612 }
9613
9614 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9615 return SWIG_Python_InitShadowInstance(args);
9616 }
9617
9618 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9619 PyObject *resultobj = 0;
9620 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9621 PyObject *arg2 = (PyObject *) 0 ;
9622 void *argp1 = 0 ;
9623 int res1 = 0 ;
9624 PyObject * obj0 = 0 ;
9625 PyObject * obj1 = 0 ;
9626 char * kwnames[] = {
9627 (char *) "self",(char *) "obj", NULL
9628 };
9629
9630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9632 if (!SWIG_IsOK(res1)) {
9633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9634 }
9635 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9636 arg2 = obj1;
9637 {
9638 PyThreadState* __tstate = wxPyBeginAllowThreads();
9639 wxOutputStream_write(arg1,arg2);
9640 wxPyEndAllowThreads(__tstate);
9641 if (PyErr_Occurred()) SWIG_fail;
9642 }
9643 resultobj = SWIG_Py_Void();
9644 return resultobj;
9645 fail:
9646 return NULL;
9647 }
9648
9649
9650 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9651 PyObject *resultobj = 0;
9652 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9653 size_t result;
9654 void *argp1 = 0 ;
9655 int res1 = 0 ;
9656 PyObject *swig_obj[1] ;
9657
9658 if (!args) SWIG_fail;
9659 swig_obj[0] = args;
9660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9661 if (!SWIG_IsOK(res1)) {
9662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9663 }
9664 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9665 {
9666 PyThreadState* __tstate = wxPyBeginAllowThreads();
9667 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9668 wxPyEndAllowThreads(__tstate);
9669 if (PyErr_Occurred()) SWIG_fail;
9670 }
9671 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9672 return resultobj;
9673 fail:
9674 return NULL;
9675 }
9676
9677
9678 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9679 PyObject *obj;
9680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9681 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9682 return SWIG_Py_Void();
9683 }
9684
9685 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9686 PyObject *resultobj = 0;
9687 wxInputStream *arg1 = (wxInputStream *) 0 ;
9688 wxString *arg2 = 0 ;
9689 wxString *arg3 = 0 ;
9690 wxString *arg4 = 0 ;
9691 wxDateTime arg5 ;
9692 wxFSFile *result = 0 ;
9693 wxPyInputStream *temp1 ;
9694 bool temp2 = false ;
9695 bool temp3 = false ;
9696 bool temp4 = false ;
9697 void *argp5 ;
9698 int res5 = 0 ;
9699 PyObject * obj0 = 0 ;
9700 PyObject * obj1 = 0 ;
9701 PyObject * obj2 = 0 ;
9702 PyObject * obj3 = 0 ;
9703 PyObject * obj4 = 0 ;
9704 char * kwnames[] = {
9705 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9706 };
9707
9708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9709 {
9710 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9711 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9712 } else {
9713 PyErr_Clear(); // clear the failure of the wxPyConvert above
9714 arg1 = wxPyCBInputStream_create(obj0, true);
9715 if (arg1 == NULL) {
9716 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9717 SWIG_fail;
9718 }
9719 }
9720 }
9721 {
9722 arg2 = wxString_in_helper(obj1);
9723 if (arg2 == NULL) SWIG_fail;
9724 temp2 = true;
9725 }
9726 {
9727 arg3 = wxString_in_helper(obj2);
9728 if (arg3 == NULL) SWIG_fail;
9729 temp3 = true;
9730 }
9731 {
9732 arg4 = wxString_in_helper(obj3);
9733 if (arg4 == NULL) SWIG_fail;
9734 temp4 = true;
9735 }
9736 {
9737 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9738 if (!SWIG_IsOK(res5)) {
9739 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9740 }
9741 if (!argp5) {
9742 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9743 } else {
9744 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9745 arg5 = *temp;
9746 if (SWIG_IsNewObj(res5)) delete temp;
9747 }
9748 }
9749 {
9750 PyThreadState* __tstate = wxPyBeginAllowThreads();
9751 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9752 wxPyEndAllowThreads(__tstate);
9753 if (PyErr_Occurred()) SWIG_fail;
9754 }
9755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9756 {
9757 if (temp2)
9758 delete arg2;
9759 }
9760 {
9761 if (temp3)
9762 delete arg3;
9763 }
9764 {
9765 if (temp4)
9766 delete arg4;
9767 }
9768 return resultobj;
9769 fail:
9770 {
9771 if (temp2)
9772 delete arg2;
9773 }
9774 {
9775 if (temp3)
9776 delete arg3;
9777 }
9778 {
9779 if (temp4)
9780 delete arg4;
9781 }
9782 return NULL;
9783 }
9784
9785
9786 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9787 PyObject *resultobj = 0;
9788 wxFSFile *arg1 = (wxFSFile *) 0 ;
9789 void *argp1 = 0 ;
9790 int res1 = 0 ;
9791 PyObject *swig_obj[1] ;
9792
9793 if (!args) SWIG_fail;
9794 swig_obj[0] = args;
9795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9796 if (!SWIG_IsOK(res1)) {
9797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9798 }
9799 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9800 {
9801 PyThreadState* __tstate = wxPyBeginAllowThreads();
9802 delete arg1;
9803
9804 wxPyEndAllowThreads(__tstate);
9805 if (PyErr_Occurred()) SWIG_fail;
9806 }
9807 resultobj = SWIG_Py_Void();
9808 return resultobj;
9809 fail:
9810 return NULL;
9811 }
9812
9813
9814 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9815 PyObject *resultobj = 0;
9816 wxFSFile *arg1 = (wxFSFile *) 0 ;
9817 wxInputStream *result = 0 ;
9818 void *argp1 = 0 ;
9819 int res1 = 0 ;
9820 PyObject *swig_obj[1] ;
9821
9822 if (!args) SWIG_fail;
9823 swig_obj[0] = args;
9824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9825 if (!SWIG_IsOK(res1)) {
9826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9827 }
9828 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9829 {
9830 PyThreadState* __tstate = wxPyBeginAllowThreads();
9831 result = (wxInputStream *)(arg1)->GetStream();
9832 wxPyEndAllowThreads(__tstate);
9833 if (PyErr_Occurred()) SWIG_fail;
9834 }
9835 {
9836 wxPyInputStream * _ptr = NULL;
9837
9838 if (result) {
9839 _ptr = new wxPyInputStream(result);
9840 }
9841 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9842 }
9843 return resultobj;
9844 fail:
9845 return NULL;
9846 }
9847
9848
9849 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9850 PyObject *resultobj = 0;
9851 wxFSFile *arg1 = (wxFSFile *) 0 ;
9852 void *argp1 = 0 ;
9853 int res1 = 0 ;
9854 PyObject *swig_obj[1] ;
9855
9856 if (!args) SWIG_fail;
9857 swig_obj[0] = args;
9858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9859 if (!SWIG_IsOK(res1)) {
9860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9861 }
9862 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9863 {
9864 PyThreadState* __tstate = wxPyBeginAllowThreads();
9865 (arg1)->DetachStream();
9866 wxPyEndAllowThreads(__tstate);
9867 if (PyErr_Occurred()) SWIG_fail;
9868 }
9869 resultobj = SWIG_Py_Void();
9870 return resultobj;
9871 fail:
9872 return NULL;
9873 }
9874
9875
9876 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9877 PyObject *resultobj = 0;
9878 wxFSFile *arg1 = (wxFSFile *) 0 ;
9879 wxString *result = 0 ;
9880 void *argp1 = 0 ;
9881 int res1 = 0 ;
9882 PyObject *swig_obj[1] ;
9883
9884 if (!args) SWIG_fail;
9885 swig_obj[0] = args;
9886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9887 if (!SWIG_IsOK(res1)) {
9888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9889 }
9890 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9891 {
9892 PyThreadState* __tstate = wxPyBeginAllowThreads();
9893 {
9894 wxString const &_result_ref = (arg1)->GetMimeType();
9895 result = (wxString *) &_result_ref;
9896 }
9897 wxPyEndAllowThreads(__tstate);
9898 if (PyErr_Occurred()) SWIG_fail;
9899 }
9900 {
9901 #if wxUSE_UNICODE
9902 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9903 #else
9904 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9905 #endif
9906 }
9907 return resultobj;
9908 fail:
9909 return NULL;
9910 }
9911
9912
9913 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9914 PyObject *resultobj = 0;
9915 wxFSFile *arg1 = (wxFSFile *) 0 ;
9916 wxString *result = 0 ;
9917 void *argp1 = 0 ;
9918 int res1 = 0 ;
9919 PyObject *swig_obj[1] ;
9920
9921 if (!args) SWIG_fail;
9922 swig_obj[0] = args;
9923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9924 if (!SWIG_IsOK(res1)) {
9925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9926 }
9927 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9928 {
9929 PyThreadState* __tstate = wxPyBeginAllowThreads();
9930 {
9931 wxString const &_result_ref = (arg1)->GetLocation();
9932 result = (wxString *) &_result_ref;
9933 }
9934 wxPyEndAllowThreads(__tstate);
9935 if (PyErr_Occurred()) SWIG_fail;
9936 }
9937 {
9938 #if wxUSE_UNICODE
9939 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9940 #else
9941 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9942 #endif
9943 }
9944 return resultobj;
9945 fail:
9946 return NULL;
9947 }
9948
9949
9950 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9951 PyObject *resultobj = 0;
9952 wxFSFile *arg1 = (wxFSFile *) 0 ;
9953 wxString *result = 0 ;
9954 void *argp1 = 0 ;
9955 int res1 = 0 ;
9956 PyObject *swig_obj[1] ;
9957
9958 if (!args) SWIG_fail;
9959 swig_obj[0] = args;
9960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9961 if (!SWIG_IsOK(res1)) {
9962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9963 }
9964 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9965 {
9966 PyThreadState* __tstate = wxPyBeginAllowThreads();
9967 {
9968 wxString const &_result_ref = (arg1)->GetAnchor();
9969 result = (wxString *) &_result_ref;
9970 }
9971 wxPyEndAllowThreads(__tstate);
9972 if (PyErr_Occurred()) SWIG_fail;
9973 }
9974 {
9975 #if wxUSE_UNICODE
9976 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9977 #else
9978 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9979 #endif
9980 }
9981 return resultobj;
9982 fail:
9983 return NULL;
9984 }
9985
9986
9987 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9988 PyObject *resultobj = 0;
9989 wxFSFile *arg1 = (wxFSFile *) 0 ;
9990 wxDateTime result;
9991 void *argp1 = 0 ;
9992 int res1 = 0 ;
9993 PyObject *swig_obj[1] ;
9994
9995 if (!args) SWIG_fail;
9996 swig_obj[0] = args;
9997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9998 if (!SWIG_IsOK(res1)) {
9999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10000 }
10001 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10002 {
10003 PyThreadState* __tstate = wxPyBeginAllowThreads();
10004 result = (arg1)->GetModificationTime();
10005 wxPyEndAllowThreads(__tstate);
10006 if (PyErr_Occurred()) SWIG_fail;
10007 }
10008 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10009 return resultobj;
10010 fail:
10011 return NULL;
10012 }
10013
10014
10015 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10016 PyObject *obj;
10017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10018 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10019 return SWIG_Py_Void();
10020 }
10021
10022 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10023 return SWIG_Python_InitShadowInstance(args);
10024 }
10025
10026 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10027 PyObject *resultobj = 0;
10028 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10029 void *argp1 = 0 ;
10030 int res1 = 0 ;
10031 PyObject *swig_obj[1] ;
10032
10033 if (!args) SWIG_fail;
10034 swig_obj[0] = args;
10035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10036 if (!SWIG_IsOK(res1)) {
10037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10038 }
10039 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10040 {
10041 PyThreadState* __tstate = wxPyBeginAllowThreads();
10042 delete arg1;
10043
10044 wxPyEndAllowThreads(__tstate);
10045 if (PyErr_Occurred()) SWIG_fail;
10046 }
10047 resultobj = SWIG_Py_Void();
10048 return resultobj;
10049 fail:
10050 return NULL;
10051 }
10052
10053
10054 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10055 PyObject *obj;
10056 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10057 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10058 return SWIG_Py_Void();
10059 }
10060
10061 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10062 PyObject *resultobj = 0;
10063 wxPyFileSystemHandler *result = 0 ;
10064
10065 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10066 {
10067 PyThreadState* __tstate = wxPyBeginAllowThreads();
10068 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10069 wxPyEndAllowThreads(__tstate);
10070 if (PyErr_Occurred()) SWIG_fail;
10071 }
10072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10073 return resultobj;
10074 fail:
10075 return NULL;
10076 }
10077
10078
10079 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10080 PyObject *resultobj = 0;
10081 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10082 PyObject *arg2 = (PyObject *) 0 ;
10083 PyObject *arg3 = (PyObject *) 0 ;
10084 void *argp1 = 0 ;
10085 int res1 = 0 ;
10086 PyObject * obj0 = 0 ;
10087 PyObject * obj1 = 0 ;
10088 PyObject * obj2 = 0 ;
10089 char * kwnames[] = {
10090 (char *) "self",(char *) "self",(char *) "_class", NULL
10091 };
10092
10093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10095 if (!SWIG_IsOK(res1)) {
10096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10097 }
10098 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10099 arg2 = obj1;
10100 arg3 = obj2;
10101 {
10102 PyThreadState* __tstate = wxPyBeginAllowThreads();
10103 (arg1)->_setCallbackInfo(arg2,arg3);
10104 wxPyEndAllowThreads(__tstate);
10105 if (PyErr_Occurred()) SWIG_fail;
10106 }
10107 resultobj = SWIG_Py_Void();
10108 return resultobj;
10109 fail:
10110 return NULL;
10111 }
10112
10113
10114 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10115 PyObject *resultobj = 0;
10116 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10117 wxString *arg2 = 0 ;
10118 bool result;
10119 void *argp1 = 0 ;
10120 int res1 = 0 ;
10121 bool temp2 = false ;
10122 PyObject * obj0 = 0 ;
10123 PyObject * obj1 = 0 ;
10124 char * kwnames[] = {
10125 (char *) "self",(char *) "location", NULL
10126 };
10127
10128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10130 if (!SWIG_IsOK(res1)) {
10131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10132 }
10133 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10134 {
10135 arg2 = wxString_in_helper(obj1);
10136 if (arg2 == NULL) SWIG_fail;
10137 temp2 = true;
10138 }
10139 {
10140 PyThreadState* __tstate = wxPyBeginAllowThreads();
10141 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10142 wxPyEndAllowThreads(__tstate);
10143 if (PyErr_Occurred()) SWIG_fail;
10144 }
10145 {
10146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10147 }
10148 {
10149 if (temp2)
10150 delete arg2;
10151 }
10152 return resultobj;
10153 fail:
10154 {
10155 if (temp2)
10156 delete arg2;
10157 }
10158 return NULL;
10159 }
10160
10161
10162 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10163 PyObject *resultobj = 0;
10164 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10165 wxFileSystem *arg2 = 0 ;
10166 wxString *arg3 = 0 ;
10167 wxFSFile *result = 0 ;
10168 void *argp1 = 0 ;
10169 int res1 = 0 ;
10170 void *argp2 = 0 ;
10171 int res2 = 0 ;
10172 bool temp3 = false ;
10173 PyObject * obj0 = 0 ;
10174 PyObject * obj1 = 0 ;
10175 PyObject * obj2 = 0 ;
10176 char * kwnames[] = {
10177 (char *) "self",(char *) "fs",(char *) "location", NULL
10178 };
10179
10180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10182 if (!SWIG_IsOK(res1)) {
10183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10184 }
10185 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10186 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10187 if (!SWIG_IsOK(res2)) {
10188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10189 }
10190 if (!argp2) {
10191 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10192 }
10193 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10194 {
10195 arg3 = wxString_in_helper(obj2);
10196 if (arg3 == NULL) SWIG_fail;
10197 temp3 = true;
10198 }
10199 {
10200 PyThreadState* __tstate = wxPyBeginAllowThreads();
10201 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10202 wxPyEndAllowThreads(__tstate);
10203 if (PyErr_Occurred()) SWIG_fail;
10204 }
10205 {
10206 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10207 }
10208 {
10209 if (temp3)
10210 delete arg3;
10211 }
10212 return resultobj;
10213 fail:
10214 {
10215 if (temp3)
10216 delete arg3;
10217 }
10218 return NULL;
10219 }
10220
10221
10222 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10223 PyObject *resultobj = 0;
10224 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10225 wxString *arg2 = 0 ;
10226 int arg3 = (int) 0 ;
10227 wxString result;
10228 void *argp1 = 0 ;
10229 int res1 = 0 ;
10230 bool temp2 = false ;
10231 int val3 ;
10232 int ecode3 = 0 ;
10233 PyObject * obj0 = 0 ;
10234 PyObject * obj1 = 0 ;
10235 PyObject * obj2 = 0 ;
10236 char * kwnames[] = {
10237 (char *) "self",(char *) "spec",(char *) "flags", NULL
10238 };
10239
10240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10242 if (!SWIG_IsOK(res1)) {
10243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10244 }
10245 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10246 {
10247 arg2 = wxString_in_helper(obj1);
10248 if (arg2 == NULL) SWIG_fail;
10249 temp2 = true;
10250 }
10251 if (obj2) {
10252 ecode3 = SWIG_AsVal_int(obj2, &val3);
10253 if (!SWIG_IsOK(ecode3)) {
10254 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10255 }
10256 arg3 = static_cast< int >(val3);
10257 }
10258 {
10259 PyThreadState* __tstate = wxPyBeginAllowThreads();
10260 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10261 wxPyEndAllowThreads(__tstate);
10262 if (PyErr_Occurred()) SWIG_fail;
10263 }
10264 {
10265 #if wxUSE_UNICODE
10266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10267 #else
10268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10269 #endif
10270 }
10271 {
10272 if (temp2)
10273 delete arg2;
10274 }
10275 return resultobj;
10276 fail:
10277 {
10278 if (temp2)
10279 delete arg2;
10280 }
10281 return NULL;
10282 }
10283
10284
10285 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10286 PyObject *resultobj = 0;
10287 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10288 wxString result;
10289 void *argp1 = 0 ;
10290 int res1 = 0 ;
10291 PyObject *swig_obj[1] ;
10292
10293 if (!args) SWIG_fail;
10294 swig_obj[0] = args;
10295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10296 if (!SWIG_IsOK(res1)) {
10297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10298 }
10299 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10300 {
10301 PyThreadState* __tstate = wxPyBeginAllowThreads();
10302 result = (arg1)->FindNext();
10303 wxPyEndAllowThreads(__tstate);
10304 if (PyErr_Occurred()) SWIG_fail;
10305 }
10306 {
10307 #if wxUSE_UNICODE
10308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10309 #else
10310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10311 #endif
10312 }
10313 return resultobj;
10314 fail:
10315 return NULL;
10316 }
10317
10318
10319 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10320 PyObject *resultobj = 0;
10321 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10322 wxString *arg2 = 0 ;
10323 wxString result;
10324 void *argp1 = 0 ;
10325 int res1 = 0 ;
10326 bool temp2 = false ;
10327 PyObject * obj0 = 0 ;
10328 PyObject * obj1 = 0 ;
10329 char * kwnames[] = {
10330 (char *) "self",(char *) "location", NULL
10331 };
10332
10333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10335 if (!SWIG_IsOK(res1)) {
10336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10337 }
10338 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10339 {
10340 arg2 = wxString_in_helper(obj1);
10341 if (arg2 == NULL) SWIG_fail;
10342 temp2 = true;
10343 }
10344 {
10345 PyThreadState* __tstate = wxPyBeginAllowThreads();
10346 result = (arg1)->GetProtocol((wxString const &)*arg2);
10347 wxPyEndAllowThreads(__tstate);
10348 if (PyErr_Occurred()) SWIG_fail;
10349 }
10350 {
10351 #if wxUSE_UNICODE
10352 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10353 #else
10354 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10355 #endif
10356 }
10357 {
10358 if (temp2)
10359 delete arg2;
10360 }
10361 return resultobj;
10362 fail:
10363 {
10364 if (temp2)
10365 delete arg2;
10366 }
10367 return NULL;
10368 }
10369
10370
10371 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10372 PyObject *resultobj = 0;
10373 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10374 wxString *arg2 = 0 ;
10375 wxString result;
10376 void *argp1 = 0 ;
10377 int res1 = 0 ;
10378 bool temp2 = false ;
10379 PyObject * obj0 = 0 ;
10380 PyObject * obj1 = 0 ;
10381 char * kwnames[] = {
10382 (char *) "self",(char *) "location", NULL
10383 };
10384
10385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10387 if (!SWIG_IsOK(res1)) {
10388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10389 }
10390 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10391 {
10392 arg2 = wxString_in_helper(obj1);
10393 if (arg2 == NULL) SWIG_fail;
10394 temp2 = true;
10395 }
10396 {
10397 PyThreadState* __tstate = wxPyBeginAllowThreads();
10398 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10399 wxPyEndAllowThreads(__tstate);
10400 if (PyErr_Occurred()) SWIG_fail;
10401 }
10402 {
10403 #if wxUSE_UNICODE
10404 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10405 #else
10406 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10407 #endif
10408 }
10409 {
10410 if (temp2)
10411 delete arg2;
10412 }
10413 return resultobj;
10414 fail:
10415 {
10416 if (temp2)
10417 delete arg2;
10418 }
10419 return NULL;
10420 }
10421
10422
10423 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10424 PyObject *resultobj = 0;
10425 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10426 wxString *arg2 = 0 ;
10427 wxString result;
10428 void *argp1 = 0 ;
10429 int res1 = 0 ;
10430 bool temp2 = false ;
10431 PyObject * obj0 = 0 ;
10432 PyObject * obj1 = 0 ;
10433 char * kwnames[] = {
10434 (char *) "self",(char *) "location", NULL
10435 };
10436
10437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10439 if (!SWIG_IsOK(res1)) {
10440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10441 }
10442 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10443 {
10444 arg2 = wxString_in_helper(obj1);
10445 if (arg2 == NULL) SWIG_fail;
10446 temp2 = true;
10447 }
10448 {
10449 PyThreadState* __tstate = wxPyBeginAllowThreads();
10450 result = (arg1)->GetAnchor((wxString const &)*arg2);
10451 wxPyEndAllowThreads(__tstate);
10452 if (PyErr_Occurred()) SWIG_fail;
10453 }
10454 {
10455 #if wxUSE_UNICODE
10456 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10457 #else
10458 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10459 #endif
10460 }
10461 {
10462 if (temp2)
10463 delete arg2;
10464 }
10465 return resultobj;
10466 fail:
10467 {
10468 if (temp2)
10469 delete arg2;
10470 }
10471 return NULL;
10472 }
10473
10474
10475 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10476 PyObject *resultobj = 0;
10477 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10478 wxString *arg2 = 0 ;
10479 wxString result;
10480 void *argp1 = 0 ;
10481 int res1 = 0 ;
10482 bool temp2 = false ;
10483 PyObject * obj0 = 0 ;
10484 PyObject * obj1 = 0 ;
10485 char * kwnames[] = {
10486 (char *) "self",(char *) "location", NULL
10487 };
10488
10489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10491 if (!SWIG_IsOK(res1)) {
10492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10493 }
10494 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10495 {
10496 arg2 = wxString_in_helper(obj1);
10497 if (arg2 == NULL) SWIG_fail;
10498 temp2 = true;
10499 }
10500 {
10501 PyThreadState* __tstate = wxPyBeginAllowThreads();
10502 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10503 wxPyEndAllowThreads(__tstate);
10504 if (PyErr_Occurred()) SWIG_fail;
10505 }
10506 {
10507 #if wxUSE_UNICODE
10508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10509 #else
10510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10511 #endif
10512 }
10513 {
10514 if (temp2)
10515 delete arg2;
10516 }
10517 return resultobj;
10518 fail:
10519 {
10520 if (temp2)
10521 delete arg2;
10522 }
10523 return NULL;
10524 }
10525
10526
10527 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10528 PyObject *resultobj = 0;
10529 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10530 wxString *arg2 = 0 ;
10531 wxString result;
10532 void *argp1 = 0 ;
10533 int res1 = 0 ;
10534 bool temp2 = false ;
10535 PyObject * obj0 = 0 ;
10536 PyObject * obj1 = 0 ;
10537 char * kwnames[] = {
10538 (char *) "self",(char *) "location", NULL
10539 };
10540
10541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10543 if (!SWIG_IsOK(res1)) {
10544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10545 }
10546 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10547 {
10548 arg2 = wxString_in_helper(obj1);
10549 if (arg2 == NULL) SWIG_fail;
10550 temp2 = true;
10551 }
10552 {
10553 PyThreadState* __tstate = wxPyBeginAllowThreads();
10554 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10555 wxPyEndAllowThreads(__tstate);
10556 if (PyErr_Occurred()) SWIG_fail;
10557 }
10558 {
10559 #if wxUSE_UNICODE
10560 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10561 #else
10562 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10563 #endif
10564 }
10565 {
10566 if (temp2)
10567 delete arg2;
10568 }
10569 return resultobj;
10570 fail:
10571 {
10572 if (temp2)
10573 delete arg2;
10574 }
10575 return NULL;
10576 }
10577
10578
10579 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10580 PyObject *obj;
10581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10582 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10583 return SWIG_Py_Void();
10584 }
10585
10586 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10587 return SWIG_Python_InitShadowInstance(args);
10588 }
10589
10590 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10591 PyObject *resultobj = 0;
10592 wxFileSystem *result = 0 ;
10593
10594 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10595 {
10596 PyThreadState* __tstate = wxPyBeginAllowThreads();
10597 result = (wxFileSystem *)new wxFileSystem();
10598 wxPyEndAllowThreads(__tstate);
10599 if (PyErr_Occurred()) SWIG_fail;
10600 }
10601 {
10602 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10603 }
10604 return resultobj;
10605 fail:
10606 return NULL;
10607 }
10608
10609
10610 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10611 PyObject *resultobj = 0;
10612 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10613 void *argp1 = 0 ;
10614 int res1 = 0 ;
10615 PyObject *swig_obj[1] ;
10616
10617 if (!args) SWIG_fail;
10618 swig_obj[0] = args;
10619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10620 if (!SWIG_IsOK(res1)) {
10621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10622 }
10623 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10624 {
10625 PyThreadState* __tstate = wxPyBeginAllowThreads();
10626 delete arg1;
10627
10628 wxPyEndAllowThreads(__tstate);
10629 if (PyErr_Occurred()) SWIG_fail;
10630 }
10631 resultobj = SWIG_Py_Void();
10632 return resultobj;
10633 fail:
10634 return NULL;
10635 }
10636
10637
10638 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10639 PyObject *resultobj = 0;
10640 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10641 wxString *arg2 = 0 ;
10642 bool arg3 = (bool) false ;
10643 void *argp1 = 0 ;
10644 int res1 = 0 ;
10645 bool temp2 = false ;
10646 bool val3 ;
10647 int ecode3 = 0 ;
10648 PyObject * obj0 = 0 ;
10649 PyObject * obj1 = 0 ;
10650 PyObject * obj2 = 0 ;
10651 char * kwnames[] = {
10652 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10653 };
10654
10655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10657 if (!SWIG_IsOK(res1)) {
10658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10659 }
10660 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10661 {
10662 arg2 = wxString_in_helper(obj1);
10663 if (arg2 == NULL) SWIG_fail;
10664 temp2 = true;
10665 }
10666 if (obj2) {
10667 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10668 if (!SWIG_IsOK(ecode3)) {
10669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10670 }
10671 arg3 = static_cast< bool >(val3);
10672 }
10673 {
10674 PyThreadState* __tstate = wxPyBeginAllowThreads();
10675 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10676 wxPyEndAllowThreads(__tstate);
10677 if (PyErr_Occurred()) SWIG_fail;
10678 }
10679 resultobj = SWIG_Py_Void();
10680 {
10681 if (temp2)
10682 delete arg2;
10683 }
10684 return resultobj;
10685 fail:
10686 {
10687 if (temp2)
10688 delete arg2;
10689 }
10690 return NULL;
10691 }
10692
10693
10694 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10695 PyObject *resultobj = 0;
10696 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10697 wxString result;
10698 void *argp1 = 0 ;
10699 int res1 = 0 ;
10700 PyObject *swig_obj[1] ;
10701
10702 if (!args) SWIG_fail;
10703 swig_obj[0] = args;
10704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10705 if (!SWIG_IsOK(res1)) {
10706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10707 }
10708 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10709 {
10710 PyThreadState* __tstate = wxPyBeginAllowThreads();
10711 result = (arg1)->GetPath();
10712 wxPyEndAllowThreads(__tstate);
10713 if (PyErr_Occurred()) SWIG_fail;
10714 }
10715 {
10716 #if wxUSE_UNICODE
10717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10718 #else
10719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10720 #endif
10721 }
10722 return resultobj;
10723 fail:
10724 return NULL;
10725 }
10726
10727
10728 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10729 PyObject *resultobj = 0;
10730 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10731 wxString *arg2 = 0 ;
10732 wxFSFile *result = 0 ;
10733 void *argp1 = 0 ;
10734 int res1 = 0 ;
10735 bool temp2 = false ;
10736 PyObject * obj0 = 0 ;
10737 PyObject * obj1 = 0 ;
10738 char * kwnames[] = {
10739 (char *) "self",(char *) "location", NULL
10740 };
10741
10742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10744 if (!SWIG_IsOK(res1)) {
10745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10746 }
10747 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10748 {
10749 arg2 = wxString_in_helper(obj1);
10750 if (arg2 == NULL) SWIG_fail;
10751 temp2 = true;
10752 }
10753 {
10754 PyThreadState* __tstate = wxPyBeginAllowThreads();
10755 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10756 wxPyEndAllowThreads(__tstate);
10757 if (PyErr_Occurred()) SWIG_fail;
10758 }
10759 {
10760 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10761 }
10762 {
10763 if (temp2)
10764 delete arg2;
10765 }
10766 return resultobj;
10767 fail:
10768 {
10769 if (temp2)
10770 delete arg2;
10771 }
10772 return NULL;
10773 }
10774
10775
10776 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10777 PyObject *resultobj = 0;
10778 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10779 wxString *arg2 = 0 ;
10780 int arg3 = (int) 0 ;
10781 wxString result;
10782 void *argp1 = 0 ;
10783 int res1 = 0 ;
10784 bool temp2 = false ;
10785 int val3 ;
10786 int ecode3 = 0 ;
10787 PyObject * obj0 = 0 ;
10788 PyObject * obj1 = 0 ;
10789 PyObject * obj2 = 0 ;
10790 char * kwnames[] = {
10791 (char *) "self",(char *) "spec",(char *) "flags", NULL
10792 };
10793
10794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10796 if (!SWIG_IsOK(res1)) {
10797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10798 }
10799 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10800 {
10801 arg2 = wxString_in_helper(obj1);
10802 if (arg2 == NULL) SWIG_fail;
10803 temp2 = true;
10804 }
10805 if (obj2) {
10806 ecode3 = SWIG_AsVal_int(obj2, &val3);
10807 if (!SWIG_IsOK(ecode3)) {
10808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10809 }
10810 arg3 = static_cast< int >(val3);
10811 }
10812 {
10813 PyThreadState* __tstate = wxPyBeginAllowThreads();
10814 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10815 wxPyEndAllowThreads(__tstate);
10816 if (PyErr_Occurred()) SWIG_fail;
10817 }
10818 {
10819 #if wxUSE_UNICODE
10820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10821 #else
10822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10823 #endif
10824 }
10825 {
10826 if (temp2)
10827 delete arg2;
10828 }
10829 return resultobj;
10830 fail:
10831 {
10832 if (temp2)
10833 delete arg2;
10834 }
10835 return NULL;
10836 }
10837
10838
10839 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10840 PyObject *resultobj = 0;
10841 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10842 wxString result;
10843 void *argp1 = 0 ;
10844 int res1 = 0 ;
10845 PyObject *swig_obj[1] ;
10846
10847 if (!args) SWIG_fail;
10848 swig_obj[0] = args;
10849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10850 if (!SWIG_IsOK(res1)) {
10851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10852 }
10853 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10854 {
10855 PyThreadState* __tstate = wxPyBeginAllowThreads();
10856 result = (arg1)->FindNext();
10857 wxPyEndAllowThreads(__tstate);
10858 if (PyErr_Occurred()) SWIG_fail;
10859 }
10860 {
10861 #if wxUSE_UNICODE
10862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10863 #else
10864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10865 #endif
10866 }
10867 return resultobj;
10868 fail:
10869 return NULL;
10870 }
10871
10872
10873 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10874 PyObject *resultobj = 0;
10875 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10876 int res1 = 0 ;
10877 PyObject * obj0 = 0 ;
10878 char * kwnames[] = {
10879 (char *) "handler", NULL
10880 };
10881
10882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10883 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10884 if (!SWIG_IsOK(res1)) {
10885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10886 }
10887 {
10888 PyThreadState* __tstate = wxPyBeginAllowThreads();
10889 wxFileSystem::AddHandler(arg1);
10890 wxPyEndAllowThreads(__tstate);
10891 if (PyErr_Occurred()) SWIG_fail;
10892 }
10893 resultobj = SWIG_Py_Void();
10894 return resultobj;
10895 fail:
10896 return NULL;
10897 }
10898
10899
10900 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10901 PyObject *resultobj = 0;
10902 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10903 wxFileSystemHandler *result = 0 ;
10904 void *argp1 = 0 ;
10905 int res1 = 0 ;
10906 PyObject * obj0 = 0 ;
10907 char * kwnames[] = {
10908 (char *) "handler", NULL
10909 };
10910
10911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
10912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10913 if (!SWIG_IsOK(res1)) {
10914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10915 }
10916 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10917 {
10918 PyThreadState* __tstate = wxPyBeginAllowThreads();
10919 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
10920 wxPyEndAllowThreads(__tstate);
10921 if (PyErr_Occurred()) SWIG_fail;
10922 }
10923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
10924 return resultobj;
10925 fail:
10926 return NULL;
10927 }
10928
10929
10930 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10931 PyObject *resultobj = 0;
10932
10933 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10934 {
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 wxFileSystem::CleanUpHandlers();
10937 wxPyEndAllowThreads(__tstate);
10938 if (PyErr_Occurred()) SWIG_fail;
10939 }
10940 resultobj = SWIG_Py_Void();
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj = 0;
10949 wxString *arg1 = 0 ;
10950 wxString result;
10951 bool temp1 = false ;
10952 PyObject * obj0 = 0 ;
10953 char * kwnames[] = {
10954 (char *) "filename", NULL
10955 };
10956
10957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10958 {
10959 arg1 = wxString_in_helper(obj0);
10960 if (arg1 == NULL) SWIG_fail;
10961 temp1 = true;
10962 }
10963 {
10964 PyThreadState* __tstate = wxPyBeginAllowThreads();
10965 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10966 wxPyEndAllowThreads(__tstate);
10967 if (PyErr_Occurred()) SWIG_fail;
10968 }
10969 {
10970 #if wxUSE_UNICODE
10971 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10972 #else
10973 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10974 #endif
10975 }
10976 {
10977 if (temp1)
10978 delete arg1;
10979 }
10980 return resultobj;
10981 fail:
10982 {
10983 if (temp1)
10984 delete arg1;
10985 }
10986 return NULL;
10987 }
10988
10989
10990 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10991 PyObject *resultobj = 0;
10992 wxString *arg1 = 0 ;
10993 wxString result;
10994 bool temp1 = false ;
10995 PyObject * obj0 = 0 ;
10996 char * kwnames[] = {
10997 (char *) "url", NULL
10998 };
10999
11000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11001 {
11002 arg1 = wxString_in_helper(obj0);
11003 if (arg1 == NULL) SWIG_fail;
11004 temp1 = true;
11005 }
11006 {
11007 PyThreadState* __tstate = wxPyBeginAllowThreads();
11008 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11009 wxPyEndAllowThreads(__tstate);
11010 if (PyErr_Occurred()) SWIG_fail;
11011 }
11012 {
11013 #if wxUSE_UNICODE
11014 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11015 #else
11016 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11017 #endif
11018 }
11019 {
11020 if (temp1)
11021 delete arg1;
11022 }
11023 return resultobj;
11024 fail:
11025 {
11026 if (temp1)
11027 delete arg1;
11028 }
11029 return NULL;
11030 }
11031
11032
11033 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11034 PyObject *obj;
11035 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11036 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11037 return SWIG_Py_Void();
11038 }
11039
11040 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11041 return SWIG_Python_InitShadowInstance(args);
11042 }
11043
11044 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11045 PyObject *resultobj = 0;
11046 wxInternetFSHandler *result = 0 ;
11047
11048 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11049 {
11050 PyThreadState* __tstate = wxPyBeginAllowThreads();
11051 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11052 wxPyEndAllowThreads(__tstate);
11053 if (PyErr_Occurred()) SWIG_fail;
11054 }
11055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11056 return resultobj;
11057 fail:
11058 return NULL;
11059 }
11060
11061
11062 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11063 PyObject *resultobj = 0;
11064 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11065 wxString *arg2 = 0 ;
11066 bool result;
11067 void *argp1 = 0 ;
11068 int res1 = 0 ;
11069 bool temp2 = false ;
11070 PyObject * obj0 = 0 ;
11071 PyObject * obj1 = 0 ;
11072 char * kwnames[] = {
11073 (char *) "self",(char *) "location", NULL
11074 };
11075
11076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11078 if (!SWIG_IsOK(res1)) {
11079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11080 }
11081 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11082 {
11083 arg2 = wxString_in_helper(obj1);
11084 if (arg2 == NULL) SWIG_fail;
11085 temp2 = true;
11086 }
11087 {
11088 PyThreadState* __tstate = wxPyBeginAllowThreads();
11089 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11090 wxPyEndAllowThreads(__tstate);
11091 if (PyErr_Occurred()) SWIG_fail;
11092 }
11093 {
11094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11095 }
11096 {
11097 if (temp2)
11098 delete arg2;
11099 }
11100 return resultobj;
11101 fail:
11102 {
11103 if (temp2)
11104 delete arg2;
11105 }
11106 return NULL;
11107 }
11108
11109
11110 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11111 PyObject *resultobj = 0;
11112 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11113 wxFileSystem *arg2 = 0 ;
11114 wxString *arg3 = 0 ;
11115 wxFSFile *result = 0 ;
11116 void *argp1 = 0 ;
11117 int res1 = 0 ;
11118 void *argp2 = 0 ;
11119 int res2 = 0 ;
11120 bool temp3 = false ;
11121 PyObject * obj0 = 0 ;
11122 PyObject * obj1 = 0 ;
11123 PyObject * obj2 = 0 ;
11124 char * kwnames[] = {
11125 (char *) "self",(char *) "fs",(char *) "location", NULL
11126 };
11127
11128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11130 if (!SWIG_IsOK(res1)) {
11131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11132 }
11133 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11134 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11135 if (!SWIG_IsOK(res2)) {
11136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11137 }
11138 if (!argp2) {
11139 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11140 }
11141 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11142 {
11143 arg3 = wxString_in_helper(obj2);
11144 if (arg3 == NULL) SWIG_fail;
11145 temp3 = true;
11146 }
11147 {
11148 PyThreadState* __tstate = wxPyBeginAllowThreads();
11149 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11150 wxPyEndAllowThreads(__tstate);
11151 if (PyErr_Occurred()) SWIG_fail;
11152 }
11153 {
11154 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11155 }
11156 {
11157 if (temp3)
11158 delete arg3;
11159 }
11160 return resultobj;
11161 fail:
11162 {
11163 if (temp3)
11164 delete arg3;
11165 }
11166 return NULL;
11167 }
11168
11169
11170 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11171 PyObject *obj;
11172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11173 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11174 return SWIG_Py_Void();
11175 }
11176
11177 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11178 return SWIG_Python_InitShadowInstance(args);
11179 }
11180
11181 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11182 PyObject *resultobj = 0;
11183 wxZipFSHandler *result = 0 ;
11184
11185 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11186 {
11187 PyThreadState* __tstate = wxPyBeginAllowThreads();
11188 result = (wxZipFSHandler *)new wxZipFSHandler();
11189 wxPyEndAllowThreads(__tstate);
11190 if (PyErr_Occurred()) SWIG_fail;
11191 }
11192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11193 return resultobj;
11194 fail:
11195 return NULL;
11196 }
11197
11198
11199 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11200 PyObject *resultobj = 0;
11201 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11202 wxString *arg2 = 0 ;
11203 bool result;
11204 void *argp1 = 0 ;
11205 int res1 = 0 ;
11206 bool temp2 = false ;
11207 PyObject * obj0 = 0 ;
11208 PyObject * obj1 = 0 ;
11209 char * kwnames[] = {
11210 (char *) "self",(char *) "location", NULL
11211 };
11212
11213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11215 if (!SWIG_IsOK(res1)) {
11216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11217 }
11218 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11219 {
11220 arg2 = wxString_in_helper(obj1);
11221 if (arg2 == NULL) SWIG_fail;
11222 temp2 = true;
11223 }
11224 {
11225 PyThreadState* __tstate = wxPyBeginAllowThreads();
11226 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11227 wxPyEndAllowThreads(__tstate);
11228 if (PyErr_Occurred()) SWIG_fail;
11229 }
11230 {
11231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11232 }
11233 {
11234 if (temp2)
11235 delete arg2;
11236 }
11237 return resultobj;
11238 fail:
11239 {
11240 if (temp2)
11241 delete arg2;
11242 }
11243 return NULL;
11244 }
11245
11246
11247 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11248 PyObject *resultobj = 0;
11249 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11250 wxFileSystem *arg2 = 0 ;
11251 wxString *arg3 = 0 ;
11252 wxFSFile *result = 0 ;
11253 void *argp1 = 0 ;
11254 int res1 = 0 ;
11255 void *argp2 = 0 ;
11256 int res2 = 0 ;
11257 bool temp3 = false ;
11258 PyObject * obj0 = 0 ;
11259 PyObject * obj1 = 0 ;
11260 PyObject * obj2 = 0 ;
11261 char * kwnames[] = {
11262 (char *) "self",(char *) "fs",(char *) "location", NULL
11263 };
11264
11265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11267 if (!SWIG_IsOK(res1)) {
11268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11269 }
11270 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11271 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11272 if (!SWIG_IsOK(res2)) {
11273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11274 }
11275 if (!argp2) {
11276 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11277 }
11278 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11279 {
11280 arg3 = wxString_in_helper(obj2);
11281 if (arg3 == NULL) SWIG_fail;
11282 temp3 = true;
11283 }
11284 {
11285 PyThreadState* __tstate = wxPyBeginAllowThreads();
11286 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11287 wxPyEndAllowThreads(__tstate);
11288 if (PyErr_Occurred()) SWIG_fail;
11289 }
11290 {
11291 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11292 }
11293 {
11294 if (temp3)
11295 delete arg3;
11296 }
11297 return resultobj;
11298 fail:
11299 {
11300 if (temp3)
11301 delete arg3;
11302 }
11303 return NULL;
11304 }
11305
11306
11307 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11308 PyObject *resultobj = 0;
11309 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11310 wxString *arg2 = 0 ;
11311 int arg3 = (int) 0 ;
11312 wxString result;
11313 void *argp1 = 0 ;
11314 int res1 = 0 ;
11315 bool temp2 = false ;
11316 int val3 ;
11317 int ecode3 = 0 ;
11318 PyObject * obj0 = 0 ;
11319 PyObject * obj1 = 0 ;
11320 PyObject * obj2 = 0 ;
11321 char * kwnames[] = {
11322 (char *) "self",(char *) "spec",(char *) "flags", NULL
11323 };
11324
11325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11327 if (!SWIG_IsOK(res1)) {
11328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11329 }
11330 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11331 {
11332 arg2 = wxString_in_helper(obj1);
11333 if (arg2 == NULL) SWIG_fail;
11334 temp2 = true;
11335 }
11336 if (obj2) {
11337 ecode3 = SWIG_AsVal_int(obj2, &val3);
11338 if (!SWIG_IsOK(ecode3)) {
11339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11340 }
11341 arg3 = static_cast< int >(val3);
11342 }
11343 {
11344 PyThreadState* __tstate = wxPyBeginAllowThreads();
11345 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11346 wxPyEndAllowThreads(__tstate);
11347 if (PyErr_Occurred()) SWIG_fail;
11348 }
11349 {
11350 #if wxUSE_UNICODE
11351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11352 #else
11353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11354 #endif
11355 }
11356 {
11357 if (temp2)
11358 delete arg2;
11359 }
11360 return resultobj;
11361 fail:
11362 {
11363 if (temp2)
11364 delete arg2;
11365 }
11366 return NULL;
11367 }
11368
11369
11370 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11371 PyObject *resultobj = 0;
11372 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11373 wxString result;
11374 void *argp1 = 0 ;
11375 int res1 = 0 ;
11376 PyObject *swig_obj[1] ;
11377
11378 if (!args) SWIG_fail;
11379 swig_obj[0] = args;
11380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11381 if (!SWIG_IsOK(res1)) {
11382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11383 }
11384 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11385 {
11386 PyThreadState* __tstate = wxPyBeginAllowThreads();
11387 result = (arg1)->FindNext();
11388 wxPyEndAllowThreads(__tstate);
11389 if (PyErr_Occurred()) SWIG_fail;
11390 }
11391 {
11392 #if wxUSE_UNICODE
11393 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11394 #else
11395 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11396 #endif
11397 }
11398 return resultobj;
11399 fail:
11400 return NULL;
11401 }
11402
11403
11404 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11405 PyObject *obj;
11406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11407 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11408 return SWIG_Py_Void();
11409 }
11410
11411 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11412 return SWIG_Python_InitShadowInstance(args);
11413 }
11414
11415 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11416 PyObject *resultobj = 0;
11417 wxString *arg1 = 0 ;
11418 wxImage *arg2 = 0 ;
11419 long arg3 ;
11420 bool temp1 = false ;
11421 void *argp2 = 0 ;
11422 int res2 = 0 ;
11423 long val3 ;
11424 int ecode3 = 0 ;
11425 PyObject * obj0 = 0 ;
11426 PyObject * obj1 = 0 ;
11427 PyObject * obj2 = 0 ;
11428 char * kwnames[] = {
11429 (char *) "filename",(char *) "image",(char *) "type", NULL
11430 };
11431
11432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11433 {
11434 arg1 = wxString_in_helper(obj0);
11435 if (arg1 == NULL) SWIG_fail;
11436 temp1 = true;
11437 }
11438 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11439 if (!SWIG_IsOK(res2)) {
11440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11441 }
11442 if (!argp2) {
11443 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11444 }
11445 arg2 = reinterpret_cast< wxImage * >(argp2);
11446 ecode3 = SWIG_AsVal_long(obj2, &val3);
11447 if (!SWIG_IsOK(ecode3)) {
11448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11449 }
11450 arg3 = static_cast< long >(val3);
11451 {
11452 PyThreadState* __tstate = wxPyBeginAllowThreads();
11453 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11454 wxPyEndAllowThreads(__tstate);
11455 if (PyErr_Occurred()) SWIG_fail;
11456 }
11457 resultobj = SWIG_Py_Void();
11458 {
11459 if (temp1)
11460 delete arg1;
11461 }
11462 return resultobj;
11463 fail:
11464 {
11465 if (temp1)
11466 delete arg1;
11467 }
11468 return NULL;
11469 }
11470
11471
11472 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11473 PyObject *resultobj = 0;
11474 wxString *arg1 = 0 ;
11475 wxBitmap *arg2 = 0 ;
11476 long arg3 ;
11477 bool temp1 = false ;
11478 void *argp2 = 0 ;
11479 int res2 = 0 ;
11480 long val3 ;
11481 int ecode3 = 0 ;
11482 PyObject * obj0 = 0 ;
11483 PyObject * obj1 = 0 ;
11484 PyObject * obj2 = 0 ;
11485 char * kwnames[] = {
11486 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11487 };
11488
11489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11490 {
11491 arg1 = wxString_in_helper(obj0);
11492 if (arg1 == NULL) SWIG_fail;
11493 temp1 = true;
11494 }
11495 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11496 if (!SWIG_IsOK(res2)) {
11497 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11498 }
11499 if (!argp2) {
11500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11501 }
11502 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11503 ecode3 = SWIG_AsVal_long(obj2, &val3);
11504 if (!SWIG_IsOK(ecode3)) {
11505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11506 }
11507 arg3 = static_cast< long >(val3);
11508 {
11509 PyThreadState* __tstate = wxPyBeginAllowThreads();
11510 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11511 wxPyEndAllowThreads(__tstate);
11512 if (PyErr_Occurred()) SWIG_fail;
11513 }
11514 resultobj = SWIG_Py_Void();
11515 {
11516 if (temp1)
11517 delete arg1;
11518 }
11519 return resultobj;
11520 fail:
11521 {
11522 if (temp1)
11523 delete arg1;
11524 }
11525 return NULL;
11526 }
11527
11528
11529 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11530 PyObject *resultobj = 0;
11531 wxString *arg1 = 0 ;
11532 PyObject *arg2 = (PyObject *) 0 ;
11533 bool temp1 = false ;
11534 PyObject * obj0 = 0 ;
11535 PyObject * obj1 = 0 ;
11536 char * kwnames[] = {
11537 (char *) "filename",(char *) "data", NULL
11538 };
11539
11540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11541 {
11542 arg1 = wxString_in_helper(obj0);
11543 if (arg1 == NULL) SWIG_fail;
11544 temp1 = true;
11545 }
11546 arg2 = obj1;
11547 {
11548 PyThreadState* __tstate = wxPyBeginAllowThreads();
11549 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11550 wxPyEndAllowThreads(__tstate);
11551 if (PyErr_Occurred()) SWIG_fail;
11552 }
11553 resultobj = SWIG_Py_Void();
11554 {
11555 if (temp1)
11556 delete arg1;
11557 }
11558 return resultobj;
11559 fail:
11560 {
11561 if (temp1)
11562 delete arg1;
11563 }
11564 return NULL;
11565 }
11566
11567
11568 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11569 PyObject *resultobj = 0;
11570 wxMemoryFSHandler *result = 0 ;
11571
11572 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11573 {
11574 PyThreadState* __tstate = wxPyBeginAllowThreads();
11575 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11576 wxPyEndAllowThreads(__tstate);
11577 if (PyErr_Occurred()) SWIG_fail;
11578 }
11579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11580 return resultobj;
11581 fail:
11582 return NULL;
11583 }
11584
11585
11586 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11587 PyObject *resultobj = 0;
11588 wxString *arg1 = 0 ;
11589 bool temp1 = false ;
11590 PyObject * obj0 = 0 ;
11591 char * kwnames[] = {
11592 (char *) "filename", NULL
11593 };
11594
11595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11596 {
11597 arg1 = wxString_in_helper(obj0);
11598 if (arg1 == NULL) SWIG_fail;
11599 temp1 = true;
11600 }
11601 {
11602 PyThreadState* __tstate = wxPyBeginAllowThreads();
11603 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11604 wxPyEndAllowThreads(__tstate);
11605 if (PyErr_Occurred()) SWIG_fail;
11606 }
11607 resultobj = SWIG_Py_Void();
11608 {
11609 if (temp1)
11610 delete arg1;
11611 }
11612 return resultobj;
11613 fail:
11614 {
11615 if (temp1)
11616 delete arg1;
11617 }
11618 return NULL;
11619 }
11620
11621
11622 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11623 PyObject *resultobj = 0;
11624 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11625 wxString *arg2 = 0 ;
11626 bool result;
11627 void *argp1 = 0 ;
11628 int res1 = 0 ;
11629 bool temp2 = false ;
11630 PyObject * obj0 = 0 ;
11631 PyObject * obj1 = 0 ;
11632 char * kwnames[] = {
11633 (char *) "self",(char *) "location", NULL
11634 };
11635
11636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11638 if (!SWIG_IsOK(res1)) {
11639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11640 }
11641 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11642 {
11643 arg2 = wxString_in_helper(obj1);
11644 if (arg2 == NULL) SWIG_fail;
11645 temp2 = true;
11646 }
11647 {
11648 PyThreadState* __tstate = wxPyBeginAllowThreads();
11649 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11650 wxPyEndAllowThreads(__tstate);
11651 if (PyErr_Occurred()) SWIG_fail;
11652 }
11653 {
11654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11655 }
11656 {
11657 if (temp2)
11658 delete arg2;
11659 }
11660 return resultobj;
11661 fail:
11662 {
11663 if (temp2)
11664 delete arg2;
11665 }
11666 return NULL;
11667 }
11668
11669
11670 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11671 PyObject *resultobj = 0;
11672 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11673 wxFileSystem *arg2 = 0 ;
11674 wxString *arg3 = 0 ;
11675 wxFSFile *result = 0 ;
11676 void *argp1 = 0 ;
11677 int res1 = 0 ;
11678 void *argp2 = 0 ;
11679 int res2 = 0 ;
11680 bool temp3 = false ;
11681 PyObject * obj0 = 0 ;
11682 PyObject * obj1 = 0 ;
11683 PyObject * obj2 = 0 ;
11684 char * kwnames[] = {
11685 (char *) "self",(char *) "fs",(char *) "location", NULL
11686 };
11687
11688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11690 if (!SWIG_IsOK(res1)) {
11691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11692 }
11693 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11694 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11695 if (!SWIG_IsOK(res2)) {
11696 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11697 }
11698 if (!argp2) {
11699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11700 }
11701 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11702 {
11703 arg3 = wxString_in_helper(obj2);
11704 if (arg3 == NULL) SWIG_fail;
11705 temp3 = true;
11706 }
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11710 wxPyEndAllowThreads(__tstate);
11711 if (PyErr_Occurred()) SWIG_fail;
11712 }
11713 {
11714 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11715 }
11716 {
11717 if (temp3)
11718 delete arg3;
11719 }
11720 return resultobj;
11721 fail:
11722 {
11723 if (temp3)
11724 delete arg3;
11725 }
11726 return NULL;
11727 }
11728
11729
11730 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11731 PyObject *resultobj = 0;
11732 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11733 wxString *arg2 = 0 ;
11734 int arg3 = (int) 0 ;
11735 wxString result;
11736 void *argp1 = 0 ;
11737 int res1 = 0 ;
11738 bool temp2 = false ;
11739 int val3 ;
11740 int ecode3 = 0 ;
11741 PyObject * obj0 = 0 ;
11742 PyObject * obj1 = 0 ;
11743 PyObject * obj2 = 0 ;
11744 char * kwnames[] = {
11745 (char *) "self",(char *) "spec",(char *) "flags", NULL
11746 };
11747
11748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11750 if (!SWIG_IsOK(res1)) {
11751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11752 }
11753 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11754 {
11755 arg2 = wxString_in_helper(obj1);
11756 if (arg2 == NULL) SWIG_fail;
11757 temp2 = true;
11758 }
11759 if (obj2) {
11760 ecode3 = SWIG_AsVal_int(obj2, &val3);
11761 if (!SWIG_IsOK(ecode3)) {
11762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11763 }
11764 arg3 = static_cast< int >(val3);
11765 }
11766 {
11767 PyThreadState* __tstate = wxPyBeginAllowThreads();
11768 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 {
11773 #if wxUSE_UNICODE
11774 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11775 #else
11776 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11777 #endif
11778 }
11779 {
11780 if (temp2)
11781 delete arg2;
11782 }
11783 return resultobj;
11784 fail:
11785 {
11786 if (temp2)
11787 delete arg2;
11788 }
11789 return NULL;
11790 }
11791
11792
11793 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11794 PyObject *resultobj = 0;
11795 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11796 wxString result;
11797 void *argp1 = 0 ;
11798 int res1 = 0 ;
11799 PyObject *swig_obj[1] ;
11800
11801 if (!args) SWIG_fail;
11802 swig_obj[0] = args;
11803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11804 if (!SWIG_IsOK(res1)) {
11805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11806 }
11807 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11808 {
11809 PyThreadState* __tstate = wxPyBeginAllowThreads();
11810 result = (arg1)->FindNext();
11811 wxPyEndAllowThreads(__tstate);
11812 if (PyErr_Occurred()) SWIG_fail;
11813 }
11814 {
11815 #if wxUSE_UNICODE
11816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11817 #else
11818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11819 #endif
11820 }
11821 return resultobj;
11822 fail:
11823 return NULL;
11824 }
11825
11826
11827 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11828 PyObject *obj;
11829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11830 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11831 return SWIG_Py_Void();
11832 }
11833
11834 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11835 return SWIG_Python_InitShadowInstance(args);
11836 }
11837
11838 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11839 PyObject *resultobj = 0;
11840 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11841 wxString result;
11842 void *argp1 = 0 ;
11843 int res1 = 0 ;
11844 PyObject *swig_obj[1] ;
11845
11846 if (!args) SWIG_fail;
11847 swig_obj[0] = args;
11848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11849 if (!SWIG_IsOK(res1)) {
11850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11851 }
11852 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11853 {
11854 PyThreadState* __tstate = wxPyBeginAllowThreads();
11855 result = (arg1)->GetName();
11856 wxPyEndAllowThreads(__tstate);
11857 if (PyErr_Occurred()) SWIG_fail;
11858 }
11859 {
11860 #if wxUSE_UNICODE
11861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11862 #else
11863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11864 #endif
11865 }
11866 return resultobj;
11867 fail:
11868 return NULL;
11869 }
11870
11871
11872 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11873 PyObject *resultobj = 0;
11874 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11875 wxString result;
11876 void *argp1 = 0 ;
11877 int res1 = 0 ;
11878 PyObject *swig_obj[1] ;
11879
11880 if (!args) SWIG_fail;
11881 swig_obj[0] = args;
11882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11883 if (!SWIG_IsOK(res1)) {
11884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11885 }
11886 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11887 {
11888 PyThreadState* __tstate = wxPyBeginAllowThreads();
11889 result = (arg1)->GetExtension();
11890 wxPyEndAllowThreads(__tstate);
11891 if (PyErr_Occurred()) SWIG_fail;
11892 }
11893 {
11894 #if wxUSE_UNICODE
11895 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11896 #else
11897 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11898 #endif
11899 }
11900 return resultobj;
11901 fail:
11902 return NULL;
11903 }
11904
11905
11906 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11907 PyObject *resultobj = 0;
11908 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11909 long result;
11910 void *argp1 = 0 ;
11911 int res1 = 0 ;
11912 PyObject *swig_obj[1] ;
11913
11914 if (!args) SWIG_fail;
11915 swig_obj[0] = args;
11916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11917 if (!SWIG_IsOK(res1)) {
11918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11919 }
11920 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11921 {
11922 PyThreadState* __tstate = wxPyBeginAllowThreads();
11923 result = (long)(arg1)->GetType();
11924 wxPyEndAllowThreads(__tstate);
11925 if (PyErr_Occurred()) SWIG_fail;
11926 }
11927 resultobj = SWIG_From_long(static_cast< long >(result));
11928 return resultobj;
11929 fail:
11930 return NULL;
11931 }
11932
11933
11934 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11935 PyObject *resultobj = 0;
11936 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11937 wxString result;
11938 void *argp1 = 0 ;
11939 int res1 = 0 ;
11940 PyObject *swig_obj[1] ;
11941
11942 if (!args) SWIG_fail;
11943 swig_obj[0] = args;
11944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11945 if (!SWIG_IsOK(res1)) {
11946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11947 }
11948 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11949 {
11950 PyThreadState* __tstate = wxPyBeginAllowThreads();
11951 result = (arg1)->GetMimeType();
11952 wxPyEndAllowThreads(__tstate);
11953 if (PyErr_Occurred()) SWIG_fail;
11954 }
11955 {
11956 #if wxUSE_UNICODE
11957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11958 #else
11959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11960 #endif
11961 }
11962 return resultobj;
11963 fail:
11964 return NULL;
11965 }
11966
11967
11968 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11969 PyObject *resultobj = 0;
11970 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11971 wxString *arg2 = 0 ;
11972 bool result;
11973 void *argp1 = 0 ;
11974 int res1 = 0 ;
11975 bool temp2 = false ;
11976 PyObject * obj0 = 0 ;
11977 PyObject * obj1 = 0 ;
11978 char * kwnames[] = {
11979 (char *) "self",(char *) "name", NULL
11980 };
11981
11982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11984 if (!SWIG_IsOK(res1)) {
11985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11986 }
11987 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11988 {
11989 arg2 = wxString_in_helper(obj1);
11990 if (arg2 == NULL) SWIG_fail;
11991 temp2 = true;
11992 }
11993 {
11994 PyThreadState* __tstate = wxPyBeginAllowThreads();
11995 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11996 wxPyEndAllowThreads(__tstate);
11997 if (PyErr_Occurred()) SWIG_fail;
11998 }
11999 {
12000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12001 }
12002 {
12003 if (temp2)
12004 delete arg2;
12005 }
12006 return resultobj;
12007 fail:
12008 {
12009 if (temp2)
12010 delete arg2;
12011 }
12012 return NULL;
12013 }
12014
12015
12016 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12017 PyObject *resultobj = 0;
12018 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12019 wxInputStream *arg2 = 0 ;
12020 bool result;
12021 void *argp1 = 0 ;
12022 int res1 = 0 ;
12023 wxPyInputStream *temp2 ;
12024 bool created2 ;
12025 PyObject * obj0 = 0 ;
12026 PyObject * obj1 = 0 ;
12027 char * kwnames[] = {
12028 (char *) "self",(char *) "stream", NULL
12029 };
12030
12031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12033 if (!SWIG_IsOK(res1)) {
12034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12035 }
12036 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12037 {
12038 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12039 arg2 = temp2->m_wxis;
12040 created2 = false;
12041 } else {
12042 PyErr_Clear(); // clear the failure of the wxPyConvert above
12043 arg2 = wxPyCBInputStream_create(obj1, false);
12044 if (arg2 == NULL) {
12045 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12046 SWIG_fail;
12047 }
12048 created2 = true;
12049 }
12050 }
12051 {
12052 PyThreadState* __tstate = wxPyBeginAllowThreads();
12053 result = (bool)(arg1)->CanRead(*arg2);
12054 wxPyEndAllowThreads(__tstate);
12055 if (PyErr_Occurred()) SWIG_fail;
12056 }
12057 {
12058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12059 }
12060 {
12061 if (created2) delete arg2;
12062 }
12063 return resultobj;
12064 fail:
12065 {
12066 if (created2) delete arg2;
12067 }
12068 return NULL;
12069 }
12070
12071
12072 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12073 PyObject *resultobj = 0;
12074 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12075 wxString *arg2 = 0 ;
12076 void *argp1 = 0 ;
12077 int res1 = 0 ;
12078 bool temp2 = false ;
12079 PyObject * obj0 = 0 ;
12080 PyObject * obj1 = 0 ;
12081 char * kwnames[] = {
12082 (char *) "self",(char *) "name", NULL
12083 };
12084
12085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12087 if (!SWIG_IsOK(res1)) {
12088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12089 }
12090 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12091 {
12092 arg2 = wxString_in_helper(obj1);
12093 if (arg2 == NULL) SWIG_fail;
12094 temp2 = true;
12095 }
12096 {
12097 PyThreadState* __tstate = wxPyBeginAllowThreads();
12098 (arg1)->SetName((wxString const &)*arg2);
12099 wxPyEndAllowThreads(__tstate);
12100 if (PyErr_Occurred()) SWIG_fail;
12101 }
12102 resultobj = SWIG_Py_Void();
12103 {
12104 if (temp2)
12105 delete arg2;
12106 }
12107 return resultobj;
12108 fail:
12109 {
12110 if (temp2)
12111 delete arg2;
12112 }
12113 return NULL;
12114 }
12115
12116
12117 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12118 PyObject *resultobj = 0;
12119 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12120 wxString *arg2 = 0 ;
12121 void *argp1 = 0 ;
12122 int res1 = 0 ;
12123 bool temp2 = false ;
12124 PyObject * obj0 = 0 ;
12125 PyObject * obj1 = 0 ;
12126 char * kwnames[] = {
12127 (char *) "self",(char *) "extension", NULL
12128 };
12129
12130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12132 if (!SWIG_IsOK(res1)) {
12133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12134 }
12135 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12136 {
12137 arg2 = wxString_in_helper(obj1);
12138 if (arg2 == NULL) SWIG_fail;
12139 temp2 = true;
12140 }
12141 {
12142 PyThreadState* __tstate = wxPyBeginAllowThreads();
12143 (arg1)->SetExtension((wxString const &)*arg2);
12144 wxPyEndAllowThreads(__tstate);
12145 if (PyErr_Occurred()) SWIG_fail;
12146 }
12147 resultobj = SWIG_Py_Void();
12148 {
12149 if (temp2)
12150 delete arg2;
12151 }
12152 return resultobj;
12153 fail:
12154 {
12155 if (temp2)
12156 delete arg2;
12157 }
12158 return NULL;
12159 }
12160
12161
12162 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12163 PyObject *resultobj = 0;
12164 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12165 long arg2 ;
12166 void *argp1 = 0 ;
12167 int res1 = 0 ;
12168 long val2 ;
12169 int ecode2 = 0 ;
12170 PyObject * obj0 = 0 ;
12171 PyObject * obj1 = 0 ;
12172 char * kwnames[] = {
12173 (char *) "self",(char *) "type", NULL
12174 };
12175
12176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12178 if (!SWIG_IsOK(res1)) {
12179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12180 }
12181 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12182 ecode2 = SWIG_AsVal_long(obj1, &val2);
12183 if (!SWIG_IsOK(ecode2)) {
12184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12185 }
12186 arg2 = static_cast< long >(val2);
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 (arg1)->SetType(arg2);
12190 wxPyEndAllowThreads(__tstate);
12191 if (PyErr_Occurred()) SWIG_fail;
12192 }
12193 resultobj = SWIG_Py_Void();
12194 return resultobj;
12195 fail:
12196 return NULL;
12197 }
12198
12199
12200 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12201 PyObject *resultobj = 0;
12202 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12203 wxString *arg2 = 0 ;
12204 void *argp1 = 0 ;
12205 int res1 = 0 ;
12206 bool temp2 = false ;
12207 PyObject * obj0 = 0 ;
12208 PyObject * obj1 = 0 ;
12209 char * kwnames[] = {
12210 (char *) "self",(char *) "mimetype", NULL
12211 };
12212
12213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12215 if (!SWIG_IsOK(res1)) {
12216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12217 }
12218 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12219 {
12220 arg2 = wxString_in_helper(obj1);
12221 if (arg2 == NULL) SWIG_fail;
12222 temp2 = true;
12223 }
12224 {
12225 PyThreadState* __tstate = wxPyBeginAllowThreads();
12226 (arg1)->SetMimeType((wxString const &)*arg2);
12227 wxPyEndAllowThreads(__tstate);
12228 if (PyErr_Occurred()) SWIG_fail;
12229 }
12230 resultobj = SWIG_Py_Void();
12231 {
12232 if (temp2)
12233 delete arg2;
12234 }
12235 return resultobj;
12236 fail:
12237 {
12238 if (temp2)
12239 delete arg2;
12240 }
12241 return NULL;
12242 }
12243
12244
12245 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12246 PyObject *obj;
12247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12248 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12249 return SWIG_Py_Void();
12250 }
12251
12252 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12253 PyObject *resultobj = 0;
12254 wxPyImageHandler *result = 0 ;
12255
12256 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12257 {
12258 PyThreadState* __tstate = wxPyBeginAllowThreads();
12259 result = (wxPyImageHandler *)new wxPyImageHandler();
12260 wxPyEndAllowThreads(__tstate);
12261 if (PyErr_Occurred()) SWIG_fail;
12262 }
12263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12264 return resultobj;
12265 fail:
12266 return NULL;
12267 }
12268
12269
12270 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12271 PyObject *resultobj = 0;
12272 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12273 PyObject *arg2 = (PyObject *) 0 ;
12274 void *argp1 = 0 ;
12275 int res1 = 0 ;
12276 PyObject * obj0 = 0 ;
12277 PyObject * obj1 = 0 ;
12278 char * kwnames[] = {
12279 (char *) "self",(char *) "self", NULL
12280 };
12281
12282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12284 if (!SWIG_IsOK(res1)) {
12285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12286 }
12287 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12288 arg2 = obj1;
12289 {
12290 PyThreadState* __tstate = wxPyBeginAllowThreads();
12291 (arg1)->_SetSelf(arg2);
12292 wxPyEndAllowThreads(__tstate);
12293 if (PyErr_Occurred()) SWIG_fail;
12294 }
12295 resultobj = SWIG_Py_Void();
12296 return resultobj;
12297 fail:
12298 return NULL;
12299 }
12300
12301
12302 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12303 PyObject *obj;
12304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12305 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12306 return SWIG_Py_Void();
12307 }
12308
12309 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12310 return SWIG_Python_InitShadowInstance(args);
12311 }
12312
12313 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12314 PyObject *resultobj = 0;
12315 wxImageHistogram *result = 0 ;
12316
12317 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12318 {
12319 PyThreadState* __tstate = wxPyBeginAllowThreads();
12320 result = (wxImageHistogram *)new wxImageHistogram();
12321 wxPyEndAllowThreads(__tstate);
12322 if (PyErr_Occurred()) SWIG_fail;
12323 }
12324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12325 return resultobj;
12326 fail:
12327 return NULL;
12328 }
12329
12330
12331 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12332 PyObject *resultobj = 0;
12333 byte arg1 ;
12334 byte arg2 ;
12335 byte arg3 ;
12336 unsigned long result;
12337 unsigned char val1 ;
12338 int ecode1 = 0 ;
12339 unsigned char val2 ;
12340 int ecode2 = 0 ;
12341 unsigned char val3 ;
12342 int ecode3 = 0 ;
12343 PyObject * obj0 = 0 ;
12344 PyObject * obj1 = 0 ;
12345 PyObject * obj2 = 0 ;
12346 char * kwnames[] = {
12347 (char *) "r",(char *) "g",(char *) "b", NULL
12348 };
12349
12350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12351 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12352 if (!SWIG_IsOK(ecode1)) {
12353 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12354 }
12355 arg1 = static_cast< byte >(val1);
12356 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12357 if (!SWIG_IsOK(ecode2)) {
12358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12359 }
12360 arg2 = static_cast< byte >(val2);
12361 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12362 if (!SWIG_IsOK(ecode3)) {
12363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12364 }
12365 arg3 = static_cast< byte >(val3);
12366 {
12367 PyThreadState* __tstate = wxPyBeginAllowThreads();
12368 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12369 wxPyEndAllowThreads(__tstate);
12370 if (PyErr_Occurred()) SWIG_fail;
12371 }
12372 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12373 return resultobj;
12374 fail:
12375 return NULL;
12376 }
12377
12378
12379 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12380 PyObject *resultobj = 0;
12381 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12382 byte *arg2 = (byte *) 0 ;
12383 byte *arg3 = (byte *) 0 ;
12384 byte *arg4 = (byte *) 0 ;
12385 byte arg5 = (byte) 1 ;
12386 byte arg6 = (byte) 0 ;
12387 byte arg7 = (byte) 0 ;
12388 bool result;
12389 void *argp1 = 0 ;
12390 int res1 = 0 ;
12391 byte temp2 ;
12392 int res2 = SWIG_TMPOBJ ;
12393 byte temp3 ;
12394 int res3 = SWIG_TMPOBJ ;
12395 byte temp4 ;
12396 int res4 = SWIG_TMPOBJ ;
12397 unsigned char val5 ;
12398 int ecode5 = 0 ;
12399 unsigned char val6 ;
12400 int ecode6 = 0 ;
12401 unsigned char val7 ;
12402 int ecode7 = 0 ;
12403 PyObject * obj0 = 0 ;
12404 PyObject * obj1 = 0 ;
12405 PyObject * obj2 = 0 ;
12406 PyObject * obj3 = 0 ;
12407 char * kwnames[] = {
12408 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12409 };
12410
12411 arg2 = &temp2;
12412 arg3 = &temp3;
12413 arg4 = &temp4;
12414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12416 if (!SWIG_IsOK(res1)) {
12417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12418 }
12419 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12420 if (obj1) {
12421 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12422 if (!SWIG_IsOK(ecode5)) {
12423 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12424 }
12425 arg5 = static_cast< byte >(val5);
12426 }
12427 if (obj2) {
12428 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12429 if (!SWIG_IsOK(ecode6)) {
12430 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12431 }
12432 arg6 = static_cast< byte >(val6);
12433 }
12434 if (obj3) {
12435 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12436 if (!SWIG_IsOK(ecode7)) {
12437 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12438 }
12439 arg7 = static_cast< byte >(val7);
12440 }
12441 {
12442 PyThreadState* __tstate = wxPyBeginAllowThreads();
12443 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12444 wxPyEndAllowThreads(__tstate);
12445 if (PyErr_Occurred()) SWIG_fail;
12446 }
12447 {
12448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12449 }
12450 if (SWIG_IsTmpObj(res2)) {
12451 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12452 } else {
12453 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12454 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12455 }
12456 if (SWIG_IsTmpObj(res3)) {
12457 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12458 } else {
12459 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12460 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12461 }
12462 if (SWIG_IsTmpObj(res4)) {
12463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12464 } else {
12465 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12467 }
12468 return resultobj;
12469 fail:
12470 return NULL;
12471 }
12472
12473
12474 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12475 PyObject *resultobj = 0;
12476 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12477 unsigned long arg2 ;
12478 unsigned long result;
12479 void *argp1 = 0 ;
12480 int res1 = 0 ;
12481 unsigned long val2 ;
12482 int ecode2 = 0 ;
12483 PyObject * obj0 = 0 ;
12484 PyObject * obj1 = 0 ;
12485 char * kwnames[] = {
12486 (char *) "self",(char *) "key", NULL
12487 };
12488
12489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12491 if (!SWIG_IsOK(res1)) {
12492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12493 }
12494 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12495 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12496 if (!SWIG_IsOK(ecode2)) {
12497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12498 }
12499 arg2 = static_cast< unsigned long >(val2);
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12503 wxPyEndAllowThreads(__tstate);
12504 if (PyErr_Occurred()) SWIG_fail;
12505 }
12506 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12507 return resultobj;
12508 fail:
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12514 PyObject *resultobj = 0;
12515 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12516 byte arg2 ;
12517 byte arg3 ;
12518 byte arg4 ;
12519 unsigned long result;
12520 void *argp1 = 0 ;
12521 int res1 = 0 ;
12522 unsigned char val2 ;
12523 int ecode2 = 0 ;
12524 unsigned char val3 ;
12525 int ecode3 = 0 ;
12526 unsigned char val4 ;
12527 int ecode4 = 0 ;
12528 PyObject * obj0 = 0 ;
12529 PyObject * obj1 = 0 ;
12530 PyObject * obj2 = 0 ;
12531 PyObject * obj3 = 0 ;
12532 char * kwnames[] = {
12533 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12534 };
12535
12536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12538 if (!SWIG_IsOK(res1)) {
12539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12540 }
12541 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12542 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12543 if (!SWIG_IsOK(ecode2)) {
12544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12545 }
12546 arg2 = static_cast< byte >(val2);
12547 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12548 if (!SWIG_IsOK(ecode3)) {
12549 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12550 }
12551 arg3 = static_cast< byte >(val3);
12552 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12553 if (!SWIG_IsOK(ecode4)) {
12554 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12555 }
12556 arg4 = static_cast< byte >(val4);
12557 {
12558 PyThreadState* __tstate = wxPyBeginAllowThreads();
12559 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12560 wxPyEndAllowThreads(__tstate);
12561 if (PyErr_Occurred()) SWIG_fail;
12562 }
12563 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12564 return resultobj;
12565 fail:
12566 return NULL;
12567 }
12568
12569
12570 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12571 PyObject *resultobj = 0;
12572 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12573 wxColour *arg2 = 0 ;
12574 unsigned long result;
12575 void *argp1 = 0 ;
12576 int res1 = 0 ;
12577 wxColour temp2 ;
12578 PyObject * obj0 = 0 ;
12579 PyObject * obj1 = 0 ;
12580 char * kwnames[] = {
12581 (char *) "self",(char *) "colour", NULL
12582 };
12583
12584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12586 if (!SWIG_IsOK(res1)) {
12587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12588 }
12589 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12590 {
12591 arg2 = &temp2;
12592 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12593 }
12594 {
12595 PyThreadState* __tstate = wxPyBeginAllowThreads();
12596 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12597 wxPyEndAllowThreads(__tstate);
12598 if (PyErr_Occurred()) SWIG_fail;
12599 }
12600 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12601 return resultobj;
12602 fail:
12603 return NULL;
12604 }
12605
12606
12607 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12608 PyObject *obj;
12609 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12610 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12611 return SWIG_Py_Void();
12612 }
12613
12614 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12615 return SWIG_Python_InitShadowInstance(args);
12616 }
12617
12618 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12619 PyObject *resultobj = 0;
12620 byte arg1 = (byte) 0 ;
12621 byte arg2 = (byte) 0 ;
12622 byte arg3 = (byte) 0 ;
12623 wxImage_RGBValue *result = 0 ;
12624 unsigned char val1 ;
12625 int ecode1 = 0 ;
12626 unsigned char val2 ;
12627 int ecode2 = 0 ;
12628 unsigned char val3 ;
12629 int ecode3 = 0 ;
12630 PyObject * obj0 = 0 ;
12631 PyObject * obj1 = 0 ;
12632 PyObject * obj2 = 0 ;
12633 char * kwnames[] = {
12634 (char *) "r",(char *) "g",(char *) "b", NULL
12635 };
12636
12637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12638 if (obj0) {
12639 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12640 if (!SWIG_IsOK(ecode1)) {
12641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12642 }
12643 arg1 = static_cast< byte >(val1);
12644 }
12645 if (obj1) {
12646 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12647 if (!SWIG_IsOK(ecode2)) {
12648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12649 }
12650 arg2 = static_cast< byte >(val2);
12651 }
12652 if (obj2) {
12653 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12654 if (!SWIG_IsOK(ecode3)) {
12655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12656 }
12657 arg3 = static_cast< byte >(val3);
12658 }
12659 {
12660 PyThreadState* __tstate = wxPyBeginAllowThreads();
12661 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12662 wxPyEndAllowThreads(__tstate);
12663 if (PyErr_Occurred()) SWIG_fail;
12664 }
12665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12666 return resultobj;
12667 fail:
12668 return NULL;
12669 }
12670
12671
12672 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12673 PyObject *resultobj = 0;
12674 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12675 byte arg2 ;
12676 void *argp1 = 0 ;
12677 int res1 = 0 ;
12678 unsigned char val2 ;
12679 int ecode2 = 0 ;
12680 PyObject *swig_obj[2] ;
12681
12682 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12684 if (!SWIG_IsOK(res1)) {
12685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12686 }
12687 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12688 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12689 if (!SWIG_IsOK(ecode2)) {
12690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12691 }
12692 arg2 = static_cast< byte >(val2);
12693 if (arg1) (arg1)->red = arg2;
12694
12695 resultobj = SWIG_Py_Void();
12696 return resultobj;
12697 fail:
12698 return NULL;
12699 }
12700
12701
12702 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12703 PyObject *resultobj = 0;
12704 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12705 byte result;
12706 void *argp1 = 0 ;
12707 int res1 = 0 ;
12708 PyObject *swig_obj[1] ;
12709
12710 if (!args) SWIG_fail;
12711 swig_obj[0] = args;
12712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12713 if (!SWIG_IsOK(res1)) {
12714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12715 }
12716 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12717 result = (byte) ((arg1)->red);
12718 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12719 return resultobj;
12720 fail:
12721 return NULL;
12722 }
12723
12724
12725 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12726 PyObject *resultobj = 0;
12727 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12728 byte arg2 ;
12729 void *argp1 = 0 ;
12730 int res1 = 0 ;
12731 unsigned char val2 ;
12732 int ecode2 = 0 ;
12733 PyObject *swig_obj[2] ;
12734
12735 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12737 if (!SWIG_IsOK(res1)) {
12738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12739 }
12740 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12741 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12742 if (!SWIG_IsOK(ecode2)) {
12743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12744 }
12745 arg2 = static_cast< byte >(val2);
12746 if (arg1) (arg1)->green = arg2;
12747
12748 resultobj = SWIG_Py_Void();
12749 return resultobj;
12750 fail:
12751 return NULL;
12752 }
12753
12754
12755 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12756 PyObject *resultobj = 0;
12757 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12758 byte result;
12759 void *argp1 = 0 ;
12760 int res1 = 0 ;
12761 PyObject *swig_obj[1] ;
12762
12763 if (!args) SWIG_fail;
12764 swig_obj[0] = args;
12765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12766 if (!SWIG_IsOK(res1)) {
12767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12768 }
12769 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12770 result = (byte) ((arg1)->green);
12771 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12772 return resultobj;
12773 fail:
12774 return NULL;
12775 }
12776
12777
12778 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12779 PyObject *resultobj = 0;
12780 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12781 byte arg2 ;
12782 void *argp1 = 0 ;
12783 int res1 = 0 ;
12784 unsigned char val2 ;
12785 int ecode2 = 0 ;
12786 PyObject *swig_obj[2] ;
12787
12788 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12790 if (!SWIG_IsOK(res1)) {
12791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12792 }
12793 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12794 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12795 if (!SWIG_IsOK(ecode2)) {
12796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12797 }
12798 arg2 = static_cast< byte >(val2);
12799 if (arg1) (arg1)->blue = arg2;
12800
12801 resultobj = SWIG_Py_Void();
12802 return resultobj;
12803 fail:
12804 return NULL;
12805 }
12806
12807
12808 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12809 PyObject *resultobj = 0;
12810 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12811 byte result;
12812 void *argp1 = 0 ;
12813 int res1 = 0 ;
12814 PyObject *swig_obj[1] ;
12815
12816 if (!args) SWIG_fail;
12817 swig_obj[0] = args;
12818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12819 if (!SWIG_IsOK(res1)) {
12820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12821 }
12822 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12823 result = (byte) ((arg1)->blue);
12824 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12825 return resultobj;
12826 fail:
12827 return NULL;
12828 }
12829
12830
12831 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12832 PyObject *obj;
12833 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12834 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12835 return SWIG_Py_Void();
12836 }
12837
12838 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12839 return SWIG_Python_InitShadowInstance(args);
12840 }
12841
12842 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12843 PyObject *resultobj = 0;
12844 double arg1 = (double) 0.0 ;
12845 double arg2 = (double) 0.0 ;
12846 double arg3 = (double) 0.0 ;
12847 wxImage_HSVValue *result = 0 ;
12848 double val1 ;
12849 int ecode1 = 0 ;
12850 double val2 ;
12851 int ecode2 = 0 ;
12852 double val3 ;
12853 int ecode3 = 0 ;
12854 PyObject * obj0 = 0 ;
12855 PyObject * obj1 = 0 ;
12856 PyObject * obj2 = 0 ;
12857 char * kwnames[] = {
12858 (char *) "h",(char *) "s",(char *) "v", NULL
12859 };
12860
12861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12862 if (obj0) {
12863 ecode1 = SWIG_AsVal_double(obj0, &val1);
12864 if (!SWIG_IsOK(ecode1)) {
12865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12866 }
12867 arg1 = static_cast< double >(val1);
12868 }
12869 if (obj1) {
12870 ecode2 = SWIG_AsVal_double(obj1, &val2);
12871 if (!SWIG_IsOK(ecode2)) {
12872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12873 }
12874 arg2 = static_cast< double >(val2);
12875 }
12876 if (obj2) {
12877 ecode3 = SWIG_AsVal_double(obj2, &val3);
12878 if (!SWIG_IsOK(ecode3)) {
12879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12880 }
12881 arg3 = static_cast< double >(val3);
12882 }
12883 {
12884 PyThreadState* __tstate = wxPyBeginAllowThreads();
12885 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12886 wxPyEndAllowThreads(__tstate);
12887 if (PyErr_Occurred()) SWIG_fail;
12888 }
12889 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12890 return resultobj;
12891 fail:
12892 return NULL;
12893 }
12894
12895
12896 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12897 PyObject *resultobj = 0;
12898 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12899 double arg2 ;
12900 void *argp1 = 0 ;
12901 int res1 = 0 ;
12902 double val2 ;
12903 int ecode2 = 0 ;
12904 PyObject *swig_obj[2] ;
12905
12906 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12908 if (!SWIG_IsOK(res1)) {
12909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12910 }
12911 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12912 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12913 if (!SWIG_IsOK(ecode2)) {
12914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12915 }
12916 arg2 = static_cast< double >(val2);
12917 if (arg1) (arg1)->hue = arg2;
12918
12919 resultobj = SWIG_Py_Void();
12920 return resultobj;
12921 fail:
12922 return NULL;
12923 }
12924
12925
12926 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12927 PyObject *resultobj = 0;
12928 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12929 double result;
12930 void *argp1 = 0 ;
12931 int res1 = 0 ;
12932 PyObject *swig_obj[1] ;
12933
12934 if (!args) SWIG_fail;
12935 swig_obj[0] = args;
12936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12937 if (!SWIG_IsOK(res1)) {
12938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12939 }
12940 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12941 result = (double) ((arg1)->hue);
12942 resultobj = SWIG_From_double(static_cast< double >(result));
12943 return resultobj;
12944 fail:
12945 return NULL;
12946 }
12947
12948
12949 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12950 PyObject *resultobj = 0;
12951 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12952 double arg2 ;
12953 void *argp1 = 0 ;
12954 int res1 = 0 ;
12955 double val2 ;
12956 int ecode2 = 0 ;
12957 PyObject *swig_obj[2] ;
12958
12959 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12961 if (!SWIG_IsOK(res1)) {
12962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12963 }
12964 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12965 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12966 if (!SWIG_IsOK(ecode2)) {
12967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12968 }
12969 arg2 = static_cast< double >(val2);
12970 if (arg1) (arg1)->saturation = arg2;
12971
12972 resultobj = SWIG_Py_Void();
12973 return resultobj;
12974 fail:
12975 return NULL;
12976 }
12977
12978
12979 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12980 PyObject *resultobj = 0;
12981 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12982 double result;
12983 void *argp1 = 0 ;
12984 int res1 = 0 ;
12985 PyObject *swig_obj[1] ;
12986
12987 if (!args) SWIG_fail;
12988 swig_obj[0] = args;
12989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12990 if (!SWIG_IsOK(res1)) {
12991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12992 }
12993 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12994 result = (double) ((arg1)->saturation);
12995 resultobj = SWIG_From_double(static_cast< double >(result));
12996 return resultobj;
12997 fail:
12998 return NULL;
12999 }
13000
13001
13002 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13003 PyObject *resultobj = 0;
13004 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13005 double arg2 ;
13006 void *argp1 = 0 ;
13007 int res1 = 0 ;
13008 double val2 ;
13009 int ecode2 = 0 ;
13010 PyObject *swig_obj[2] ;
13011
13012 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13014 if (!SWIG_IsOK(res1)) {
13015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13016 }
13017 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13018 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13019 if (!SWIG_IsOK(ecode2)) {
13020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13021 }
13022 arg2 = static_cast< double >(val2);
13023 if (arg1) (arg1)->value = arg2;
13024
13025 resultobj = SWIG_Py_Void();
13026 return resultobj;
13027 fail:
13028 return NULL;
13029 }
13030
13031
13032 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13033 PyObject *resultobj = 0;
13034 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13035 double result;
13036 void *argp1 = 0 ;
13037 int res1 = 0 ;
13038 PyObject *swig_obj[1] ;
13039
13040 if (!args) SWIG_fail;
13041 swig_obj[0] = args;
13042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13043 if (!SWIG_IsOK(res1)) {
13044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13045 }
13046 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13047 result = (double) ((arg1)->value);
13048 resultobj = SWIG_From_double(static_cast< double >(result));
13049 return resultobj;
13050 fail:
13051 return NULL;
13052 }
13053
13054
13055 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13056 PyObject *obj;
13057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13058 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13059 return SWIG_Py_Void();
13060 }
13061
13062 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13063 return SWIG_Python_InitShadowInstance(args);
13064 }
13065
13066 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13067 PyObject *resultobj = 0;
13068 wxString *arg1 = 0 ;
13069 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13070 int arg3 = (int) -1 ;
13071 wxImage *result = 0 ;
13072 bool temp1 = false ;
13073 long val2 ;
13074 int ecode2 = 0 ;
13075 int val3 ;
13076 int ecode3 = 0 ;
13077 PyObject * obj0 = 0 ;
13078 PyObject * obj1 = 0 ;
13079 PyObject * obj2 = 0 ;
13080 char * kwnames[] = {
13081 (char *) "name",(char *) "type",(char *) "index", NULL
13082 };
13083
13084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13085 {
13086 arg1 = wxString_in_helper(obj0);
13087 if (arg1 == NULL) SWIG_fail;
13088 temp1 = true;
13089 }
13090 if (obj1) {
13091 ecode2 = SWIG_AsVal_long(obj1, &val2);
13092 if (!SWIG_IsOK(ecode2)) {
13093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13094 }
13095 arg2 = static_cast< long >(val2);
13096 }
13097 if (obj2) {
13098 ecode3 = SWIG_AsVal_int(obj2, &val3);
13099 if (!SWIG_IsOK(ecode3)) {
13100 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13101 }
13102 arg3 = static_cast< int >(val3);
13103 }
13104 {
13105 PyThreadState* __tstate = wxPyBeginAllowThreads();
13106 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13107 wxPyEndAllowThreads(__tstate);
13108 if (PyErr_Occurred()) SWIG_fail;
13109 }
13110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13111 {
13112 if (temp1)
13113 delete arg1;
13114 }
13115 return resultobj;
13116 fail:
13117 {
13118 if (temp1)
13119 delete arg1;
13120 }
13121 return NULL;
13122 }
13123
13124
13125 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13126 PyObject *resultobj = 0;
13127 wxImage *arg1 = (wxImage *) 0 ;
13128 void *argp1 = 0 ;
13129 int res1 = 0 ;
13130 PyObject *swig_obj[1] ;
13131
13132 if (!args) SWIG_fail;
13133 swig_obj[0] = args;
13134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13135 if (!SWIG_IsOK(res1)) {
13136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13137 }
13138 arg1 = reinterpret_cast< wxImage * >(argp1);
13139 {
13140 PyThreadState* __tstate = wxPyBeginAllowThreads();
13141 delete arg1;
13142
13143 wxPyEndAllowThreads(__tstate);
13144 if (PyErr_Occurred()) SWIG_fail;
13145 }
13146 resultobj = SWIG_Py_Void();
13147 return resultobj;
13148 fail:
13149 return NULL;
13150 }
13151
13152
13153 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13154 PyObject *resultobj = 0;
13155 wxString *arg1 = 0 ;
13156 wxString *arg2 = 0 ;
13157 int arg3 = (int) -1 ;
13158 wxImage *result = 0 ;
13159 bool temp1 = false ;
13160 bool temp2 = false ;
13161 int val3 ;
13162 int ecode3 = 0 ;
13163 PyObject * obj0 = 0 ;
13164 PyObject * obj1 = 0 ;
13165 PyObject * obj2 = 0 ;
13166 char * kwnames[] = {
13167 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13168 };
13169
13170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13171 {
13172 arg1 = wxString_in_helper(obj0);
13173 if (arg1 == NULL) SWIG_fail;
13174 temp1 = true;
13175 }
13176 {
13177 arg2 = wxString_in_helper(obj1);
13178 if (arg2 == NULL) SWIG_fail;
13179 temp2 = true;
13180 }
13181 if (obj2) {
13182 ecode3 = SWIG_AsVal_int(obj2, &val3);
13183 if (!SWIG_IsOK(ecode3)) {
13184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13185 }
13186 arg3 = static_cast< int >(val3);
13187 }
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13191 wxPyEndAllowThreads(__tstate);
13192 if (PyErr_Occurred()) SWIG_fail;
13193 }
13194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13195 {
13196 if (temp1)
13197 delete arg1;
13198 }
13199 {
13200 if (temp2)
13201 delete arg2;
13202 }
13203 return resultobj;
13204 fail:
13205 {
13206 if (temp1)
13207 delete arg1;
13208 }
13209 {
13210 if (temp2)
13211 delete arg2;
13212 }
13213 return NULL;
13214 }
13215
13216
13217 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13218 PyObject *resultobj = 0;
13219 wxInputStream *arg1 = 0 ;
13220 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13221 int arg3 = (int) -1 ;
13222 wxImage *result = 0 ;
13223 wxPyInputStream *temp1 ;
13224 bool created1 ;
13225 long val2 ;
13226 int ecode2 = 0 ;
13227 int val3 ;
13228 int ecode3 = 0 ;
13229 PyObject * obj0 = 0 ;
13230 PyObject * obj1 = 0 ;
13231 PyObject * obj2 = 0 ;
13232 char * kwnames[] = {
13233 (char *) "stream",(char *) "type",(char *) "index", NULL
13234 };
13235
13236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13237 {
13238 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13239 arg1 = temp1->m_wxis;
13240 created1 = false;
13241 } else {
13242 PyErr_Clear(); // clear the failure of the wxPyConvert above
13243 arg1 = wxPyCBInputStream_create(obj0, false);
13244 if (arg1 == NULL) {
13245 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13246 SWIG_fail;
13247 }
13248 created1 = true;
13249 }
13250 }
13251 if (obj1) {
13252 ecode2 = SWIG_AsVal_long(obj1, &val2);
13253 if (!SWIG_IsOK(ecode2)) {
13254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13255 }
13256 arg2 = static_cast< long >(val2);
13257 }
13258 if (obj2) {
13259 ecode3 = SWIG_AsVal_int(obj2, &val3);
13260 if (!SWIG_IsOK(ecode3)) {
13261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13262 }
13263 arg3 = static_cast< int >(val3);
13264 }
13265 {
13266 PyThreadState* __tstate = wxPyBeginAllowThreads();
13267 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13268 wxPyEndAllowThreads(__tstate);
13269 if (PyErr_Occurred()) SWIG_fail;
13270 }
13271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13272 {
13273 if (created1) delete arg1;
13274 }
13275 return resultobj;
13276 fail:
13277 {
13278 if (created1) delete arg1;
13279 }
13280 return NULL;
13281 }
13282
13283
13284 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13285 PyObject *resultobj = 0;
13286 wxInputStream *arg1 = 0 ;
13287 wxString *arg2 = 0 ;
13288 int arg3 = (int) -1 ;
13289 wxImage *result = 0 ;
13290 wxPyInputStream *temp1 ;
13291 bool created1 ;
13292 bool temp2 = false ;
13293 int val3 ;
13294 int ecode3 = 0 ;
13295 PyObject * obj0 = 0 ;
13296 PyObject * obj1 = 0 ;
13297 PyObject * obj2 = 0 ;
13298 char * kwnames[] = {
13299 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13300 };
13301
13302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13303 {
13304 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13305 arg1 = temp1->m_wxis;
13306 created1 = false;
13307 } else {
13308 PyErr_Clear(); // clear the failure of the wxPyConvert above
13309 arg1 = wxPyCBInputStream_create(obj0, false);
13310 if (arg1 == NULL) {
13311 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13312 SWIG_fail;
13313 }
13314 created1 = true;
13315 }
13316 }
13317 {
13318 arg2 = wxString_in_helper(obj1);
13319 if (arg2 == NULL) SWIG_fail;
13320 temp2 = true;
13321 }
13322 if (obj2) {
13323 ecode3 = SWIG_AsVal_int(obj2, &val3);
13324 if (!SWIG_IsOK(ecode3)) {
13325 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13326 }
13327 arg3 = static_cast< int >(val3);
13328 }
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13336 {
13337 if (created1) delete arg1;
13338 }
13339 {
13340 if (temp2)
13341 delete arg2;
13342 }
13343 return resultobj;
13344 fail:
13345 {
13346 if (created1) delete arg1;
13347 }
13348 {
13349 if (temp2)
13350 delete arg2;
13351 }
13352 return NULL;
13353 }
13354
13355
13356 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13357 PyObject *resultobj = 0;
13358 int arg1 = (int) 0 ;
13359 int arg2 = (int) 0 ;
13360 bool arg3 = (bool) true ;
13361 wxImage *result = 0 ;
13362 int val1 ;
13363 int ecode1 = 0 ;
13364 int val2 ;
13365 int ecode2 = 0 ;
13366 bool val3 ;
13367 int ecode3 = 0 ;
13368 PyObject * obj0 = 0 ;
13369 PyObject * obj1 = 0 ;
13370 PyObject * obj2 = 0 ;
13371 char * kwnames[] = {
13372 (char *) "width",(char *) "height",(char *) "clear", NULL
13373 };
13374
13375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13376 if (obj0) {
13377 ecode1 = SWIG_AsVal_int(obj0, &val1);
13378 if (!SWIG_IsOK(ecode1)) {
13379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13380 }
13381 arg1 = static_cast< int >(val1);
13382 }
13383 if (obj1) {
13384 ecode2 = SWIG_AsVal_int(obj1, &val2);
13385 if (!SWIG_IsOK(ecode2)) {
13386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13387 }
13388 arg2 = static_cast< int >(val2);
13389 }
13390 if (obj2) {
13391 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13392 if (!SWIG_IsOK(ecode3)) {
13393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13394 }
13395 arg3 = static_cast< bool >(val3);
13396 }
13397 {
13398 PyThreadState* __tstate = wxPyBeginAllowThreads();
13399 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13400 wxPyEndAllowThreads(__tstate);
13401 if (PyErr_Occurred()) SWIG_fail;
13402 }
13403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13404 return resultobj;
13405 fail:
13406 return NULL;
13407 }
13408
13409
13410 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13411 PyObject *resultobj = 0;
13412 wxBitmap *arg1 = 0 ;
13413 wxImage *result = 0 ;
13414 void *argp1 = 0 ;
13415 int res1 = 0 ;
13416 PyObject * obj0 = 0 ;
13417 char * kwnames[] = {
13418 (char *) "bitmap", NULL
13419 };
13420
13421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13422 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13423 if (!SWIG_IsOK(res1)) {
13424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13425 }
13426 if (!argp1) {
13427 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13428 }
13429 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13430 {
13431 if (!wxPyCheckForApp()) SWIG_fail;
13432 PyThreadState* __tstate = wxPyBeginAllowThreads();
13433 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13434 wxPyEndAllowThreads(__tstate);
13435 if (PyErr_Occurred()) SWIG_fail;
13436 }
13437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13438 return resultobj;
13439 fail:
13440 return NULL;
13441 }
13442
13443
13444 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13445 PyObject *resultobj = 0;
13446 int arg1 ;
13447 int arg2 ;
13448 buffer arg3 ;
13449 int arg4 ;
13450 wxImage *result = 0 ;
13451 int val1 ;
13452 int ecode1 = 0 ;
13453 int val2 ;
13454 int ecode2 = 0 ;
13455 Py_ssize_t temp3 ;
13456 PyObject * obj0 = 0 ;
13457 PyObject * obj1 = 0 ;
13458 PyObject * obj2 = 0 ;
13459 char * kwnames[] = {
13460 (char *) "width",(char *) "height",(char *) "data", NULL
13461 };
13462
13463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13464 ecode1 = SWIG_AsVal_int(obj0, &val1);
13465 if (!SWIG_IsOK(ecode1)) {
13466 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13467 }
13468 arg1 = static_cast< int >(val1);
13469 ecode2 = SWIG_AsVal_int(obj1, &val2);
13470 if (!SWIG_IsOK(ecode2)) {
13471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13472 }
13473 arg2 = static_cast< int >(val2);
13474 {
13475 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13476 arg4 = (int)temp3;
13477 }
13478 {
13479 PyThreadState* __tstate = wxPyBeginAllowThreads();
13480 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13481 wxPyEndAllowThreads(__tstate);
13482 if (PyErr_Occurred()) SWIG_fail;
13483 }
13484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13485 return resultobj;
13486 fail:
13487 return NULL;
13488 }
13489
13490
13491 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13492 PyObject *resultobj = 0;
13493 int arg1 ;
13494 int arg2 ;
13495 buffer arg3 ;
13496 int arg4 ;
13497 buffer arg5 ;
13498 int arg6 ;
13499 wxImage *result = 0 ;
13500 int val1 ;
13501 int ecode1 = 0 ;
13502 int val2 ;
13503 int ecode2 = 0 ;
13504 Py_ssize_t temp3 ;
13505 Py_ssize_t temp5 ;
13506 PyObject * obj0 = 0 ;
13507 PyObject * obj1 = 0 ;
13508 PyObject * obj2 = 0 ;
13509 PyObject * obj3 = 0 ;
13510 char * kwnames[] = {
13511 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13512 };
13513
13514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13515 ecode1 = SWIG_AsVal_int(obj0, &val1);
13516 if (!SWIG_IsOK(ecode1)) {
13517 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13518 }
13519 arg1 = static_cast< int >(val1);
13520 ecode2 = SWIG_AsVal_int(obj1, &val2);
13521 if (!SWIG_IsOK(ecode2)) {
13522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13523 }
13524 arg2 = static_cast< int >(val2);
13525 {
13526 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13527 arg4 = (int)temp3;
13528 }
13529 {
13530 if (obj3 != Py_None) {
13531 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13532 arg6 = (int)temp5;
13533 }
13534 }
13535 {
13536 PyThreadState* __tstate = wxPyBeginAllowThreads();
13537 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13538 wxPyEndAllowThreads(__tstate);
13539 if (PyErr_Occurred()) SWIG_fail;
13540 }
13541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13542 return resultobj;
13543 fail:
13544 return NULL;
13545 }
13546
13547
13548 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13549 PyObject *resultobj = 0;
13550 wxImage *arg1 = (wxImage *) 0 ;
13551 int arg2 ;
13552 int arg3 ;
13553 bool arg4 = (bool) true ;
13554 void *argp1 = 0 ;
13555 int res1 = 0 ;
13556 int val2 ;
13557 int ecode2 = 0 ;
13558 int val3 ;
13559 int ecode3 = 0 ;
13560 bool val4 ;
13561 int ecode4 = 0 ;
13562 PyObject * obj0 = 0 ;
13563 PyObject * obj1 = 0 ;
13564 PyObject * obj2 = 0 ;
13565 PyObject * obj3 = 0 ;
13566 char * kwnames[] = {
13567 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13568 };
13569
13570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13572 if (!SWIG_IsOK(res1)) {
13573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13574 }
13575 arg1 = reinterpret_cast< wxImage * >(argp1);
13576 ecode2 = SWIG_AsVal_int(obj1, &val2);
13577 if (!SWIG_IsOK(ecode2)) {
13578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13579 }
13580 arg2 = static_cast< int >(val2);
13581 ecode3 = SWIG_AsVal_int(obj2, &val3);
13582 if (!SWIG_IsOK(ecode3)) {
13583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13584 }
13585 arg3 = static_cast< int >(val3);
13586 if (obj3) {
13587 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13588 if (!SWIG_IsOK(ecode4)) {
13589 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13590 }
13591 arg4 = static_cast< bool >(val4);
13592 }
13593 {
13594 PyThreadState* __tstate = wxPyBeginAllowThreads();
13595 (arg1)->Create(arg2,arg3,arg4);
13596 wxPyEndAllowThreads(__tstate);
13597 if (PyErr_Occurred()) SWIG_fail;
13598 }
13599 resultobj = SWIG_Py_Void();
13600 return resultobj;
13601 fail:
13602 return NULL;
13603 }
13604
13605
13606 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13607 PyObject *resultobj = 0;
13608 wxImage *arg1 = (wxImage *) 0 ;
13609 void *argp1 = 0 ;
13610 int res1 = 0 ;
13611 PyObject *swig_obj[1] ;
13612
13613 if (!args) SWIG_fail;
13614 swig_obj[0] = args;
13615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13616 if (!SWIG_IsOK(res1)) {
13617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13618 }
13619 arg1 = reinterpret_cast< wxImage * >(argp1);
13620 {
13621 PyThreadState* __tstate = wxPyBeginAllowThreads();
13622 (arg1)->Destroy();
13623 wxPyEndAllowThreads(__tstate);
13624 if (PyErr_Occurred()) SWIG_fail;
13625 }
13626 resultobj = SWIG_Py_Void();
13627 return resultobj;
13628 fail:
13629 return NULL;
13630 }
13631
13632
13633 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13634 PyObject *resultobj = 0;
13635 wxImage *arg1 = (wxImage *) 0 ;
13636 int arg2 ;
13637 int arg3 ;
13638 SwigValueWrapper<wxImage > result;
13639 void *argp1 = 0 ;
13640 int res1 = 0 ;
13641 int val2 ;
13642 int ecode2 = 0 ;
13643 int val3 ;
13644 int ecode3 = 0 ;
13645 PyObject * obj0 = 0 ;
13646 PyObject * obj1 = 0 ;
13647 PyObject * obj2 = 0 ;
13648 char * kwnames[] = {
13649 (char *) "self",(char *) "width",(char *) "height", NULL
13650 };
13651
13652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13654 if (!SWIG_IsOK(res1)) {
13655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13656 }
13657 arg1 = reinterpret_cast< wxImage * >(argp1);
13658 ecode2 = SWIG_AsVal_int(obj1, &val2);
13659 if (!SWIG_IsOK(ecode2)) {
13660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13661 }
13662 arg2 = static_cast< int >(val2);
13663 ecode3 = SWIG_AsVal_int(obj2, &val3);
13664 if (!SWIG_IsOK(ecode3)) {
13665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13666 }
13667 arg3 = static_cast< int >(val3);
13668 {
13669 PyThreadState* __tstate = wxPyBeginAllowThreads();
13670 result = (arg1)->Scale(arg2,arg3);
13671 wxPyEndAllowThreads(__tstate);
13672 if (PyErr_Occurred()) SWIG_fail;
13673 }
13674 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13675 return resultobj;
13676 fail:
13677 return NULL;
13678 }
13679
13680
13681 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13682 PyObject *resultobj = 0;
13683 wxImage *arg1 = (wxImage *) 0 ;
13684 int arg2 ;
13685 int arg3 ;
13686 SwigValueWrapper<wxImage > result;
13687 void *argp1 = 0 ;
13688 int res1 = 0 ;
13689 int val2 ;
13690 int ecode2 = 0 ;
13691 int val3 ;
13692 int ecode3 = 0 ;
13693 PyObject * obj0 = 0 ;
13694 PyObject * obj1 = 0 ;
13695 PyObject * obj2 = 0 ;
13696 char * kwnames[] = {
13697 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13698 };
13699
13700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13702 if (!SWIG_IsOK(res1)) {
13703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13704 }
13705 arg1 = reinterpret_cast< wxImage * >(argp1);
13706 ecode2 = SWIG_AsVal_int(obj1, &val2);
13707 if (!SWIG_IsOK(ecode2)) {
13708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13709 }
13710 arg2 = static_cast< int >(val2);
13711 ecode3 = SWIG_AsVal_int(obj2, &val3);
13712 if (!SWIG_IsOK(ecode3)) {
13713 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13714 }
13715 arg3 = static_cast< int >(val3);
13716 {
13717 PyThreadState* __tstate = wxPyBeginAllowThreads();
13718 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13719 wxPyEndAllowThreads(__tstate);
13720 if (PyErr_Occurred()) SWIG_fail;
13721 }
13722 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13723 return resultobj;
13724 fail:
13725 return NULL;
13726 }
13727
13728
13729 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13730 PyObject *resultobj = 0;
13731 wxImage *arg1 = (wxImage *) 0 ;
13732 int arg2 ;
13733 int arg3 ;
13734 wxImage *result = 0 ;
13735 void *argp1 = 0 ;
13736 int res1 = 0 ;
13737 int val2 ;
13738 int ecode2 = 0 ;
13739 int val3 ;
13740 int ecode3 = 0 ;
13741 PyObject * obj0 = 0 ;
13742 PyObject * obj1 = 0 ;
13743 PyObject * obj2 = 0 ;
13744 char * kwnames[] = {
13745 (char *) "self",(char *) "width",(char *) "height", NULL
13746 };
13747
13748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13750 if (!SWIG_IsOK(res1)) {
13751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13752 }
13753 arg1 = reinterpret_cast< wxImage * >(argp1);
13754 ecode2 = SWIG_AsVal_int(obj1, &val2);
13755 if (!SWIG_IsOK(ecode2)) {
13756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13757 }
13758 arg2 = static_cast< int >(val2);
13759 ecode3 = SWIG_AsVal_int(obj2, &val3);
13760 if (!SWIG_IsOK(ecode3)) {
13761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13762 }
13763 arg3 = static_cast< int >(val3);
13764 {
13765 PyThreadState* __tstate = wxPyBeginAllowThreads();
13766 {
13767 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13768 result = (wxImage *) &_result_ref;
13769 }
13770 wxPyEndAllowThreads(__tstate);
13771 if (PyErr_Occurred()) SWIG_fail;
13772 }
13773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13774 return resultobj;
13775 fail:
13776 return NULL;
13777 }
13778
13779
13780 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13781 PyObject *resultobj = 0;
13782 wxImage *arg1 = (wxImage *) 0 ;
13783 wxSize *arg2 = 0 ;
13784 wxPoint *arg3 = 0 ;
13785 int arg4 = (int) -1 ;
13786 int arg5 = (int) -1 ;
13787 int arg6 = (int) -1 ;
13788 wxImage *result = 0 ;
13789 void *argp1 = 0 ;
13790 int res1 = 0 ;
13791 wxSize temp2 ;
13792 wxPoint temp3 ;
13793 int val4 ;
13794 int ecode4 = 0 ;
13795 int val5 ;
13796 int ecode5 = 0 ;
13797 int val6 ;
13798 int ecode6 = 0 ;
13799 PyObject * obj0 = 0 ;
13800 PyObject * obj1 = 0 ;
13801 PyObject * obj2 = 0 ;
13802 PyObject * obj3 = 0 ;
13803 PyObject * obj4 = 0 ;
13804 PyObject * obj5 = 0 ;
13805 char * kwnames[] = {
13806 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13807 };
13808
13809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13811 if (!SWIG_IsOK(res1)) {
13812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13813 }
13814 arg1 = reinterpret_cast< wxImage * >(argp1);
13815 {
13816 arg2 = &temp2;
13817 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13818 }
13819 {
13820 arg3 = &temp3;
13821 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13822 }
13823 if (obj3) {
13824 ecode4 = SWIG_AsVal_int(obj3, &val4);
13825 if (!SWIG_IsOK(ecode4)) {
13826 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13827 }
13828 arg4 = static_cast< int >(val4);
13829 }
13830 if (obj4) {
13831 ecode5 = SWIG_AsVal_int(obj4, &val5);
13832 if (!SWIG_IsOK(ecode5)) {
13833 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13834 }
13835 arg5 = static_cast< int >(val5);
13836 }
13837 if (obj5) {
13838 ecode6 = SWIG_AsVal_int(obj5, &val6);
13839 if (!SWIG_IsOK(ecode6)) {
13840 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13841 }
13842 arg6 = static_cast< int >(val6);
13843 }
13844 {
13845 PyThreadState* __tstate = wxPyBeginAllowThreads();
13846 {
13847 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13848 result = (wxImage *) &_result_ref;
13849 }
13850 wxPyEndAllowThreads(__tstate);
13851 if (PyErr_Occurred()) SWIG_fail;
13852 }
13853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13854 return resultobj;
13855 fail:
13856 return NULL;
13857 }
13858
13859
13860 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13861 PyObject *resultobj = 0;
13862 wxImage *arg1 = (wxImage *) 0 ;
13863 int arg2 ;
13864 int arg3 ;
13865 byte arg4 ;
13866 byte arg5 ;
13867 byte arg6 ;
13868 void *argp1 = 0 ;
13869 int res1 = 0 ;
13870 int val2 ;
13871 int ecode2 = 0 ;
13872 int val3 ;
13873 int ecode3 = 0 ;
13874 unsigned char val4 ;
13875 int ecode4 = 0 ;
13876 unsigned char val5 ;
13877 int ecode5 = 0 ;
13878 unsigned char val6 ;
13879 int ecode6 = 0 ;
13880 PyObject * obj0 = 0 ;
13881 PyObject * obj1 = 0 ;
13882 PyObject * obj2 = 0 ;
13883 PyObject * obj3 = 0 ;
13884 PyObject * obj4 = 0 ;
13885 PyObject * obj5 = 0 ;
13886 char * kwnames[] = {
13887 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13888 };
13889
13890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13892 if (!SWIG_IsOK(res1)) {
13893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13894 }
13895 arg1 = reinterpret_cast< wxImage * >(argp1);
13896 ecode2 = SWIG_AsVal_int(obj1, &val2);
13897 if (!SWIG_IsOK(ecode2)) {
13898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13899 }
13900 arg2 = static_cast< int >(val2);
13901 ecode3 = SWIG_AsVal_int(obj2, &val3);
13902 if (!SWIG_IsOK(ecode3)) {
13903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13904 }
13905 arg3 = static_cast< int >(val3);
13906 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13907 if (!SWIG_IsOK(ecode4)) {
13908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13909 }
13910 arg4 = static_cast< byte >(val4);
13911 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13912 if (!SWIG_IsOK(ecode5)) {
13913 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13914 }
13915 arg5 = static_cast< byte >(val5);
13916 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13917 if (!SWIG_IsOK(ecode6)) {
13918 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13919 }
13920 arg6 = static_cast< byte >(val6);
13921 {
13922 PyThreadState* __tstate = wxPyBeginAllowThreads();
13923 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13924 wxPyEndAllowThreads(__tstate);
13925 if (PyErr_Occurred()) SWIG_fail;
13926 }
13927 resultobj = SWIG_Py_Void();
13928 return resultobj;
13929 fail:
13930 return NULL;
13931 }
13932
13933
13934 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13935 PyObject *resultobj = 0;
13936 wxImage *arg1 = (wxImage *) 0 ;
13937 wxRect *arg2 = 0 ;
13938 byte arg3 ;
13939 byte arg4 ;
13940 byte arg5 ;
13941 void *argp1 = 0 ;
13942 int res1 = 0 ;
13943 wxRect temp2 ;
13944 unsigned char val3 ;
13945 int ecode3 = 0 ;
13946 unsigned char val4 ;
13947 int ecode4 = 0 ;
13948 unsigned char val5 ;
13949 int ecode5 = 0 ;
13950 PyObject * obj0 = 0 ;
13951 PyObject * obj1 = 0 ;
13952 PyObject * obj2 = 0 ;
13953 PyObject * obj3 = 0 ;
13954 PyObject * obj4 = 0 ;
13955 char * kwnames[] = {
13956 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13957 };
13958
13959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13961 if (!SWIG_IsOK(res1)) {
13962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13963 }
13964 arg1 = reinterpret_cast< wxImage * >(argp1);
13965 {
13966 arg2 = &temp2;
13967 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13968 }
13969 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13970 if (!SWIG_IsOK(ecode3)) {
13971 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13972 }
13973 arg3 = static_cast< byte >(val3);
13974 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13975 if (!SWIG_IsOK(ecode4)) {
13976 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13977 }
13978 arg4 = static_cast< byte >(val4);
13979 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13980 if (!SWIG_IsOK(ecode5)) {
13981 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13982 }
13983 arg5 = static_cast< byte >(val5);
13984 {
13985 PyThreadState* __tstate = wxPyBeginAllowThreads();
13986 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13987 wxPyEndAllowThreads(__tstate);
13988 if (PyErr_Occurred()) SWIG_fail;
13989 }
13990 resultobj = SWIG_Py_Void();
13991 return resultobj;
13992 fail:
13993 return NULL;
13994 }
13995
13996
13997 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13998 PyObject *resultobj = 0;
13999 wxImage *arg1 = (wxImage *) 0 ;
14000 int arg2 ;
14001 int arg3 ;
14002 byte result;
14003 void *argp1 = 0 ;
14004 int res1 = 0 ;
14005 int val2 ;
14006 int ecode2 = 0 ;
14007 int val3 ;
14008 int ecode3 = 0 ;
14009 PyObject * obj0 = 0 ;
14010 PyObject * obj1 = 0 ;
14011 PyObject * obj2 = 0 ;
14012 char * kwnames[] = {
14013 (char *) "self",(char *) "x",(char *) "y", NULL
14014 };
14015
14016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14018 if (!SWIG_IsOK(res1)) {
14019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14020 }
14021 arg1 = reinterpret_cast< wxImage * >(argp1);
14022 ecode2 = SWIG_AsVal_int(obj1, &val2);
14023 if (!SWIG_IsOK(ecode2)) {
14024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14025 }
14026 arg2 = static_cast< int >(val2);
14027 ecode3 = SWIG_AsVal_int(obj2, &val3);
14028 if (!SWIG_IsOK(ecode3)) {
14029 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14030 }
14031 arg3 = static_cast< int >(val3);
14032 {
14033 PyThreadState* __tstate = wxPyBeginAllowThreads();
14034 result = (byte)(arg1)->GetRed(arg2,arg3);
14035 wxPyEndAllowThreads(__tstate);
14036 if (PyErr_Occurred()) SWIG_fail;
14037 }
14038 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14039 return resultobj;
14040 fail:
14041 return NULL;
14042 }
14043
14044
14045 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14046 PyObject *resultobj = 0;
14047 wxImage *arg1 = (wxImage *) 0 ;
14048 int arg2 ;
14049 int arg3 ;
14050 byte result;
14051 void *argp1 = 0 ;
14052 int res1 = 0 ;
14053 int val2 ;
14054 int ecode2 = 0 ;
14055 int val3 ;
14056 int ecode3 = 0 ;
14057 PyObject * obj0 = 0 ;
14058 PyObject * obj1 = 0 ;
14059 PyObject * obj2 = 0 ;
14060 char * kwnames[] = {
14061 (char *) "self",(char *) "x",(char *) "y", NULL
14062 };
14063
14064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14066 if (!SWIG_IsOK(res1)) {
14067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14068 }
14069 arg1 = reinterpret_cast< wxImage * >(argp1);
14070 ecode2 = SWIG_AsVal_int(obj1, &val2);
14071 if (!SWIG_IsOK(ecode2)) {
14072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14073 }
14074 arg2 = static_cast< int >(val2);
14075 ecode3 = SWIG_AsVal_int(obj2, &val3);
14076 if (!SWIG_IsOK(ecode3)) {
14077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14078 }
14079 arg3 = static_cast< int >(val3);
14080 {
14081 PyThreadState* __tstate = wxPyBeginAllowThreads();
14082 result = (byte)(arg1)->GetGreen(arg2,arg3);
14083 wxPyEndAllowThreads(__tstate);
14084 if (PyErr_Occurred()) SWIG_fail;
14085 }
14086 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14087 return resultobj;
14088 fail:
14089 return NULL;
14090 }
14091
14092
14093 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14094 PyObject *resultobj = 0;
14095 wxImage *arg1 = (wxImage *) 0 ;
14096 int arg2 ;
14097 int arg3 ;
14098 byte result;
14099 void *argp1 = 0 ;
14100 int res1 = 0 ;
14101 int val2 ;
14102 int ecode2 = 0 ;
14103 int val3 ;
14104 int ecode3 = 0 ;
14105 PyObject * obj0 = 0 ;
14106 PyObject * obj1 = 0 ;
14107 PyObject * obj2 = 0 ;
14108 char * kwnames[] = {
14109 (char *) "self",(char *) "x",(char *) "y", NULL
14110 };
14111
14112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14114 if (!SWIG_IsOK(res1)) {
14115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14116 }
14117 arg1 = reinterpret_cast< wxImage * >(argp1);
14118 ecode2 = SWIG_AsVal_int(obj1, &val2);
14119 if (!SWIG_IsOK(ecode2)) {
14120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14121 }
14122 arg2 = static_cast< int >(val2);
14123 ecode3 = SWIG_AsVal_int(obj2, &val3);
14124 if (!SWIG_IsOK(ecode3)) {
14125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14126 }
14127 arg3 = static_cast< int >(val3);
14128 {
14129 PyThreadState* __tstate = wxPyBeginAllowThreads();
14130 result = (byte)(arg1)->GetBlue(arg2,arg3);
14131 wxPyEndAllowThreads(__tstate);
14132 if (PyErr_Occurred()) SWIG_fail;
14133 }
14134 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14135 return resultobj;
14136 fail:
14137 return NULL;
14138 }
14139
14140
14141 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14142 PyObject *resultobj = 0;
14143 wxImage *arg1 = (wxImage *) 0 ;
14144 int arg2 ;
14145 int arg3 ;
14146 byte arg4 ;
14147 void *argp1 = 0 ;
14148 int res1 = 0 ;
14149 int val2 ;
14150 int ecode2 = 0 ;
14151 int val3 ;
14152 int ecode3 = 0 ;
14153 unsigned char val4 ;
14154 int ecode4 = 0 ;
14155 PyObject * obj0 = 0 ;
14156 PyObject * obj1 = 0 ;
14157 PyObject * obj2 = 0 ;
14158 PyObject * obj3 = 0 ;
14159 char * kwnames[] = {
14160 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14161 };
14162
14163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14165 if (!SWIG_IsOK(res1)) {
14166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14167 }
14168 arg1 = reinterpret_cast< wxImage * >(argp1);
14169 ecode2 = SWIG_AsVal_int(obj1, &val2);
14170 if (!SWIG_IsOK(ecode2)) {
14171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14172 }
14173 arg2 = static_cast< int >(val2);
14174 ecode3 = SWIG_AsVal_int(obj2, &val3);
14175 if (!SWIG_IsOK(ecode3)) {
14176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14177 }
14178 arg3 = static_cast< int >(val3);
14179 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14180 if (!SWIG_IsOK(ecode4)) {
14181 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14182 }
14183 arg4 = static_cast< byte >(val4);
14184 {
14185 PyThreadState* __tstate = wxPyBeginAllowThreads();
14186 (arg1)->SetAlpha(arg2,arg3,arg4);
14187 wxPyEndAllowThreads(__tstate);
14188 if (PyErr_Occurred()) SWIG_fail;
14189 }
14190 resultobj = SWIG_Py_Void();
14191 return resultobj;
14192 fail:
14193 return NULL;
14194 }
14195
14196
14197 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14198 PyObject *resultobj = 0;
14199 wxImage *arg1 = (wxImage *) 0 ;
14200 int arg2 ;
14201 int arg3 ;
14202 byte result;
14203 void *argp1 = 0 ;
14204 int res1 = 0 ;
14205 int val2 ;
14206 int ecode2 = 0 ;
14207 int val3 ;
14208 int ecode3 = 0 ;
14209 PyObject * obj0 = 0 ;
14210 PyObject * obj1 = 0 ;
14211 PyObject * obj2 = 0 ;
14212 char * kwnames[] = {
14213 (char *) "self",(char *) "x",(char *) "y", NULL
14214 };
14215
14216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14218 if (!SWIG_IsOK(res1)) {
14219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14220 }
14221 arg1 = reinterpret_cast< wxImage * >(argp1);
14222 ecode2 = SWIG_AsVal_int(obj1, &val2);
14223 if (!SWIG_IsOK(ecode2)) {
14224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14225 }
14226 arg2 = static_cast< int >(val2);
14227 ecode3 = SWIG_AsVal_int(obj2, &val3);
14228 if (!SWIG_IsOK(ecode3)) {
14229 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14230 }
14231 arg3 = static_cast< int >(val3);
14232 {
14233 PyThreadState* __tstate = wxPyBeginAllowThreads();
14234 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14235 wxPyEndAllowThreads(__tstate);
14236 if (PyErr_Occurred()) SWIG_fail;
14237 }
14238 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14239 return resultobj;
14240 fail:
14241 return NULL;
14242 }
14243
14244
14245 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14246 PyObject *resultobj = 0;
14247 wxImage *arg1 = (wxImage *) 0 ;
14248 bool result;
14249 void *argp1 = 0 ;
14250 int res1 = 0 ;
14251 PyObject *swig_obj[1] ;
14252
14253 if (!args) SWIG_fail;
14254 swig_obj[0] = args;
14255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14256 if (!SWIG_IsOK(res1)) {
14257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14258 }
14259 arg1 = reinterpret_cast< wxImage * >(argp1);
14260 {
14261 PyThreadState* __tstate = wxPyBeginAllowThreads();
14262 result = (bool)(arg1)->HasAlpha();
14263 wxPyEndAllowThreads(__tstate);
14264 if (PyErr_Occurred()) SWIG_fail;
14265 }
14266 {
14267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14268 }
14269 return resultobj;
14270 fail:
14271 return NULL;
14272 }
14273
14274
14275 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14276 PyObject *resultobj = 0;
14277 wxImage *arg1 = (wxImage *) 0 ;
14278 void *argp1 = 0 ;
14279 int res1 = 0 ;
14280 PyObject *swig_obj[1] ;
14281
14282 if (!args) SWIG_fail;
14283 swig_obj[0] = args;
14284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14285 if (!SWIG_IsOK(res1)) {
14286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14287 }
14288 arg1 = reinterpret_cast< wxImage * >(argp1);
14289 {
14290 PyThreadState* __tstate = wxPyBeginAllowThreads();
14291 (arg1)->InitAlpha();
14292 wxPyEndAllowThreads(__tstate);
14293 if (PyErr_Occurred()) SWIG_fail;
14294 }
14295 resultobj = SWIG_Py_Void();
14296 return resultobj;
14297 fail:
14298 return NULL;
14299 }
14300
14301
14302 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14303 PyObject *resultobj = 0;
14304 wxImage *arg1 = (wxImage *) 0 ;
14305 int arg2 ;
14306 int arg3 ;
14307 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14308 bool result;
14309 void *argp1 = 0 ;
14310 int res1 = 0 ;
14311 int val2 ;
14312 int ecode2 = 0 ;
14313 int val3 ;
14314 int ecode3 = 0 ;
14315 unsigned char val4 ;
14316 int ecode4 = 0 ;
14317 PyObject * obj0 = 0 ;
14318 PyObject * obj1 = 0 ;
14319 PyObject * obj2 = 0 ;
14320 PyObject * obj3 = 0 ;
14321 char * kwnames[] = {
14322 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14323 };
14324
14325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14327 if (!SWIG_IsOK(res1)) {
14328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14329 }
14330 arg1 = reinterpret_cast< wxImage * >(argp1);
14331 ecode2 = SWIG_AsVal_int(obj1, &val2);
14332 if (!SWIG_IsOK(ecode2)) {
14333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14334 }
14335 arg2 = static_cast< int >(val2);
14336 ecode3 = SWIG_AsVal_int(obj2, &val3);
14337 if (!SWIG_IsOK(ecode3)) {
14338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14339 }
14340 arg3 = static_cast< int >(val3);
14341 if (obj3) {
14342 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14343 if (!SWIG_IsOK(ecode4)) {
14344 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14345 }
14346 arg4 = static_cast< byte >(val4);
14347 }
14348 {
14349 PyThreadState* __tstate = wxPyBeginAllowThreads();
14350 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14351 wxPyEndAllowThreads(__tstate);
14352 if (PyErr_Occurred()) SWIG_fail;
14353 }
14354 {
14355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14356 }
14357 return resultobj;
14358 fail:
14359 return NULL;
14360 }
14361
14362
14363 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14364 PyObject *resultobj = 0;
14365 wxImage *arg1 = (wxImage *) 0 ;
14366 byte *arg2 = (byte *) 0 ;
14367 byte *arg3 = (byte *) 0 ;
14368 byte *arg4 = (byte *) 0 ;
14369 byte arg5 = (byte) 0 ;
14370 byte arg6 = (byte) 0 ;
14371 byte arg7 = (byte) 0 ;
14372 bool result;
14373 void *argp1 = 0 ;
14374 int res1 = 0 ;
14375 byte temp2 ;
14376 int res2 = SWIG_TMPOBJ ;
14377 byte temp3 ;
14378 int res3 = SWIG_TMPOBJ ;
14379 byte temp4 ;
14380 int res4 = SWIG_TMPOBJ ;
14381 unsigned char val5 ;
14382 int ecode5 = 0 ;
14383 unsigned char val6 ;
14384 int ecode6 = 0 ;
14385 unsigned char val7 ;
14386 int ecode7 = 0 ;
14387 PyObject * obj0 = 0 ;
14388 PyObject * obj1 = 0 ;
14389 PyObject * obj2 = 0 ;
14390 PyObject * obj3 = 0 ;
14391 char * kwnames[] = {
14392 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14393 };
14394
14395 arg2 = &temp2;
14396 arg3 = &temp3;
14397 arg4 = &temp4;
14398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14400 if (!SWIG_IsOK(res1)) {
14401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14402 }
14403 arg1 = reinterpret_cast< wxImage * >(argp1);
14404 if (obj1) {
14405 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14406 if (!SWIG_IsOK(ecode5)) {
14407 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14408 }
14409 arg5 = static_cast< byte >(val5);
14410 }
14411 if (obj2) {
14412 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14413 if (!SWIG_IsOK(ecode6)) {
14414 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14415 }
14416 arg6 = static_cast< byte >(val6);
14417 }
14418 if (obj3) {
14419 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14420 if (!SWIG_IsOK(ecode7)) {
14421 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14422 }
14423 arg7 = static_cast< byte >(val7);
14424 }
14425 {
14426 PyThreadState* __tstate = wxPyBeginAllowThreads();
14427 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14428 wxPyEndAllowThreads(__tstate);
14429 if (PyErr_Occurred()) SWIG_fail;
14430 }
14431 {
14432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14433 }
14434 if (SWIG_IsTmpObj(res2)) {
14435 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14436 } else {
14437 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14438 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14439 }
14440 if (SWIG_IsTmpObj(res3)) {
14441 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14442 } else {
14443 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14444 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14445 }
14446 if (SWIG_IsTmpObj(res4)) {
14447 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14448 } else {
14449 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14450 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14451 }
14452 return resultobj;
14453 fail:
14454 return NULL;
14455 }
14456
14457
14458 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14459 PyObject *resultobj = 0;
14460 wxImage *arg1 = (wxImage *) 0 ;
14461 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14462 bool result;
14463 void *argp1 = 0 ;
14464 int res1 = 0 ;
14465 unsigned char val2 ;
14466 int ecode2 = 0 ;
14467 PyObject * obj0 = 0 ;
14468 PyObject * obj1 = 0 ;
14469 char * kwnames[] = {
14470 (char *) "self",(char *) "threshold", NULL
14471 };
14472
14473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14475 if (!SWIG_IsOK(res1)) {
14476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14477 }
14478 arg1 = reinterpret_cast< wxImage * >(argp1);
14479 if (obj1) {
14480 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14481 if (!SWIG_IsOK(ecode2)) {
14482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14483 }
14484 arg2 = static_cast< byte >(val2);
14485 }
14486 {
14487 PyThreadState* __tstate = wxPyBeginAllowThreads();
14488 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14489 wxPyEndAllowThreads(__tstate);
14490 if (PyErr_Occurred()) SWIG_fail;
14491 }
14492 {
14493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14494 }
14495 return resultobj;
14496 fail:
14497 return NULL;
14498 }
14499
14500
14501 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14502 PyObject *resultobj = 0;
14503 wxImage *arg1 = (wxImage *) 0 ;
14504 byte arg2 ;
14505 byte arg3 ;
14506 byte arg4 ;
14507 bool result;
14508 void *argp1 = 0 ;
14509 int res1 = 0 ;
14510 unsigned char val2 ;
14511 int ecode2 = 0 ;
14512 unsigned char val3 ;
14513 int ecode3 = 0 ;
14514 unsigned char val4 ;
14515 int ecode4 = 0 ;
14516 PyObject * obj0 = 0 ;
14517 PyObject * obj1 = 0 ;
14518 PyObject * obj2 = 0 ;
14519 PyObject * obj3 = 0 ;
14520 char * kwnames[] = {
14521 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14522 };
14523
14524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14526 if (!SWIG_IsOK(res1)) {
14527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14528 }
14529 arg1 = reinterpret_cast< wxImage * >(argp1);
14530 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14531 if (!SWIG_IsOK(ecode2)) {
14532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14533 }
14534 arg2 = static_cast< byte >(val2);
14535 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14536 if (!SWIG_IsOK(ecode3)) {
14537 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14538 }
14539 arg3 = static_cast< byte >(val3);
14540 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14541 if (!SWIG_IsOK(ecode4)) {
14542 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14543 }
14544 arg4 = static_cast< byte >(val4);
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14548 wxPyEndAllowThreads(__tstate);
14549 if (PyErr_Occurred()) SWIG_fail;
14550 }
14551 {
14552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14553 }
14554 return resultobj;
14555 fail:
14556 return NULL;
14557 }
14558
14559
14560 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14561 PyObject *resultobj = 0;
14562 wxImage *arg1 = (wxImage *) 0 ;
14563 wxImage *arg2 = 0 ;
14564 byte arg3 ;
14565 byte arg4 ;
14566 byte arg5 ;
14567 bool result;
14568 void *argp1 = 0 ;
14569 int res1 = 0 ;
14570 void *argp2 = 0 ;
14571 int res2 = 0 ;
14572 unsigned char val3 ;
14573 int ecode3 = 0 ;
14574 unsigned char val4 ;
14575 int ecode4 = 0 ;
14576 unsigned char val5 ;
14577 int ecode5 = 0 ;
14578 PyObject * obj0 = 0 ;
14579 PyObject * obj1 = 0 ;
14580 PyObject * obj2 = 0 ;
14581 PyObject * obj3 = 0 ;
14582 PyObject * obj4 = 0 ;
14583 char * kwnames[] = {
14584 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14585 };
14586
14587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14589 if (!SWIG_IsOK(res1)) {
14590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14591 }
14592 arg1 = reinterpret_cast< wxImage * >(argp1);
14593 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14594 if (!SWIG_IsOK(res2)) {
14595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14596 }
14597 if (!argp2) {
14598 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14599 }
14600 arg2 = reinterpret_cast< wxImage * >(argp2);
14601 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14602 if (!SWIG_IsOK(ecode3)) {
14603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14604 }
14605 arg3 = static_cast< byte >(val3);
14606 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14607 if (!SWIG_IsOK(ecode4)) {
14608 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14609 }
14610 arg4 = static_cast< byte >(val4);
14611 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14612 if (!SWIG_IsOK(ecode5)) {
14613 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14614 }
14615 arg5 = static_cast< byte >(val5);
14616 {
14617 PyThreadState* __tstate = wxPyBeginAllowThreads();
14618 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14619 wxPyEndAllowThreads(__tstate);
14620 if (PyErr_Occurred()) SWIG_fail;
14621 }
14622 {
14623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14624 }
14625 return resultobj;
14626 fail:
14627 return NULL;
14628 }
14629
14630
14631 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14632 PyObject *resultobj = 0;
14633 wxString *arg1 = 0 ;
14634 bool result;
14635 bool temp1 = false ;
14636 PyObject * obj0 = 0 ;
14637 char * kwnames[] = {
14638 (char *) "filename", NULL
14639 };
14640
14641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14642 {
14643 arg1 = wxString_in_helper(obj0);
14644 if (arg1 == NULL) SWIG_fail;
14645 temp1 = true;
14646 }
14647 {
14648 PyThreadState* __tstate = wxPyBeginAllowThreads();
14649 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14650 wxPyEndAllowThreads(__tstate);
14651 if (PyErr_Occurred()) SWIG_fail;
14652 }
14653 {
14654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14655 }
14656 {
14657 if (temp1)
14658 delete arg1;
14659 }
14660 return resultobj;
14661 fail:
14662 {
14663 if (temp1)
14664 delete arg1;
14665 }
14666 return NULL;
14667 }
14668
14669
14670 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14671 PyObject *resultobj = 0;
14672 wxString *arg1 = 0 ;
14673 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14674 int result;
14675 bool temp1 = false ;
14676 long val2 ;
14677 int ecode2 = 0 ;
14678 PyObject * obj0 = 0 ;
14679 PyObject * obj1 = 0 ;
14680 char * kwnames[] = {
14681 (char *) "filename",(char *) "type", NULL
14682 };
14683
14684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14685 {
14686 arg1 = wxString_in_helper(obj0);
14687 if (arg1 == NULL) SWIG_fail;
14688 temp1 = true;
14689 }
14690 if (obj1) {
14691 ecode2 = SWIG_AsVal_long(obj1, &val2);
14692 if (!SWIG_IsOK(ecode2)) {
14693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14694 }
14695 arg2 = static_cast< long >(val2);
14696 }
14697 {
14698 PyThreadState* __tstate = wxPyBeginAllowThreads();
14699 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14700 wxPyEndAllowThreads(__tstate);
14701 if (PyErr_Occurred()) SWIG_fail;
14702 }
14703 resultobj = SWIG_From_int(static_cast< int >(result));
14704 {
14705 if (temp1)
14706 delete arg1;
14707 }
14708 return resultobj;
14709 fail:
14710 {
14711 if (temp1)
14712 delete arg1;
14713 }
14714 return NULL;
14715 }
14716
14717
14718 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14719 PyObject *resultobj = 0;
14720 wxImage *arg1 = (wxImage *) 0 ;
14721 wxString *arg2 = 0 ;
14722 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14723 int arg4 = (int) -1 ;
14724 bool result;
14725 void *argp1 = 0 ;
14726 int res1 = 0 ;
14727 bool temp2 = false ;
14728 long val3 ;
14729 int ecode3 = 0 ;
14730 int val4 ;
14731 int ecode4 = 0 ;
14732 PyObject * obj0 = 0 ;
14733 PyObject * obj1 = 0 ;
14734 PyObject * obj2 = 0 ;
14735 PyObject * obj3 = 0 ;
14736 char * kwnames[] = {
14737 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14738 };
14739
14740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14742 if (!SWIG_IsOK(res1)) {
14743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14744 }
14745 arg1 = reinterpret_cast< wxImage * >(argp1);
14746 {
14747 arg2 = wxString_in_helper(obj1);
14748 if (arg2 == NULL) SWIG_fail;
14749 temp2 = true;
14750 }
14751 if (obj2) {
14752 ecode3 = SWIG_AsVal_long(obj2, &val3);
14753 if (!SWIG_IsOK(ecode3)) {
14754 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14755 }
14756 arg3 = static_cast< long >(val3);
14757 }
14758 if (obj3) {
14759 ecode4 = SWIG_AsVal_int(obj3, &val4);
14760 if (!SWIG_IsOK(ecode4)) {
14761 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14762 }
14763 arg4 = static_cast< int >(val4);
14764 }
14765 {
14766 PyThreadState* __tstate = wxPyBeginAllowThreads();
14767 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14768 wxPyEndAllowThreads(__tstate);
14769 if (PyErr_Occurred()) SWIG_fail;
14770 }
14771 {
14772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14773 }
14774 {
14775 if (temp2)
14776 delete arg2;
14777 }
14778 return resultobj;
14779 fail:
14780 {
14781 if (temp2)
14782 delete arg2;
14783 }
14784 return NULL;
14785 }
14786
14787
14788 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14789 PyObject *resultobj = 0;
14790 wxImage *arg1 = (wxImage *) 0 ;
14791 wxString *arg2 = 0 ;
14792 wxString *arg3 = 0 ;
14793 int arg4 = (int) -1 ;
14794 bool result;
14795 void *argp1 = 0 ;
14796 int res1 = 0 ;
14797 bool temp2 = false ;
14798 bool temp3 = false ;
14799 int val4 ;
14800 int ecode4 = 0 ;
14801 PyObject * obj0 = 0 ;
14802 PyObject * obj1 = 0 ;
14803 PyObject * obj2 = 0 ;
14804 PyObject * obj3 = 0 ;
14805 char * kwnames[] = {
14806 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14807 };
14808
14809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14811 if (!SWIG_IsOK(res1)) {
14812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14813 }
14814 arg1 = reinterpret_cast< wxImage * >(argp1);
14815 {
14816 arg2 = wxString_in_helper(obj1);
14817 if (arg2 == NULL) SWIG_fail;
14818 temp2 = true;
14819 }
14820 {
14821 arg3 = wxString_in_helper(obj2);
14822 if (arg3 == NULL) SWIG_fail;
14823 temp3 = true;
14824 }
14825 if (obj3) {
14826 ecode4 = SWIG_AsVal_int(obj3, &val4);
14827 if (!SWIG_IsOK(ecode4)) {
14828 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14829 }
14830 arg4 = static_cast< int >(val4);
14831 }
14832 {
14833 PyThreadState* __tstate = wxPyBeginAllowThreads();
14834 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14835 wxPyEndAllowThreads(__tstate);
14836 if (PyErr_Occurred()) SWIG_fail;
14837 }
14838 {
14839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14840 }
14841 {
14842 if (temp2)
14843 delete arg2;
14844 }
14845 {
14846 if (temp3)
14847 delete arg3;
14848 }
14849 return resultobj;
14850 fail:
14851 {
14852 if (temp2)
14853 delete arg2;
14854 }
14855 {
14856 if (temp3)
14857 delete arg3;
14858 }
14859 return NULL;
14860 }
14861
14862
14863 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14864 PyObject *resultobj = 0;
14865 wxImage *arg1 = (wxImage *) 0 ;
14866 wxString *arg2 = 0 ;
14867 int arg3 ;
14868 bool result;
14869 void *argp1 = 0 ;
14870 int res1 = 0 ;
14871 bool temp2 = false ;
14872 int val3 ;
14873 int ecode3 = 0 ;
14874 PyObject * obj0 = 0 ;
14875 PyObject * obj1 = 0 ;
14876 PyObject * obj2 = 0 ;
14877 char * kwnames[] = {
14878 (char *) "self",(char *) "name",(char *) "type", NULL
14879 };
14880
14881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14883 if (!SWIG_IsOK(res1)) {
14884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14885 }
14886 arg1 = reinterpret_cast< wxImage * >(argp1);
14887 {
14888 arg2 = wxString_in_helper(obj1);
14889 if (arg2 == NULL) SWIG_fail;
14890 temp2 = true;
14891 }
14892 ecode3 = SWIG_AsVal_int(obj2, &val3);
14893 if (!SWIG_IsOK(ecode3)) {
14894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14895 }
14896 arg3 = static_cast< int >(val3);
14897 {
14898 PyThreadState* __tstate = wxPyBeginAllowThreads();
14899 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14900 wxPyEndAllowThreads(__tstate);
14901 if (PyErr_Occurred()) SWIG_fail;
14902 }
14903 {
14904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14905 }
14906 {
14907 if (temp2)
14908 delete arg2;
14909 }
14910 return resultobj;
14911 fail:
14912 {
14913 if (temp2)
14914 delete arg2;
14915 }
14916 return NULL;
14917 }
14918
14919
14920 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14921 PyObject *resultobj = 0;
14922 wxImage *arg1 = (wxImage *) 0 ;
14923 wxString *arg2 = 0 ;
14924 wxString *arg3 = 0 ;
14925 bool result;
14926 void *argp1 = 0 ;
14927 int res1 = 0 ;
14928 bool temp2 = false ;
14929 bool temp3 = false ;
14930 PyObject * obj0 = 0 ;
14931 PyObject * obj1 = 0 ;
14932 PyObject * obj2 = 0 ;
14933 char * kwnames[] = {
14934 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14935 };
14936
14937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14939 if (!SWIG_IsOK(res1)) {
14940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14941 }
14942 arg1 = reinterpret_cast< wxImage * >(argp1);
14943 {
14944 arg2 = wxString_in_helper(obj1);
14945 if (arg2 == NULL) SWIG_fail;
14946 temp2 = true;
14947 }
14948 {
14949 arg3 = wxString_in_helper(obj2);
14950 if (arg3 == NULL) SWIG_fail;
14951 temp3 = true;
14952 }
14953 {
14954 PyThreadState* __tstate = wxPyBeginAllowThreads();
14955 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14956 wxPyEndAllowThreads(__tstate);
14957 if (PyErr_Occurred()) SWIG_fail;
14958 }
14959 {
14960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14961 }
14962 {
14963 if (temp2)
14964 delete arg2;
14965 }
14966 {
14967 if (temp3)
14968 delete arg3;
14969 }
14970 return resultobj;
14971 fail:
14972 {
14973 if (temp2)
14974 delete arg2;
14975 }
14976 {
14977 if (temp3)
14978 delete arg3;
14979 }
14980 return NULL;
14981 }
14982
14983
14984 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14985 PyObject *resultobj = 0;
14986 wxInputStream *arg1 = 0 ;
14987 bool result;
14988 wxPyInputStream *temp1 ;
14989 bool created1 ;
14990 PyObject * obj0 = 0 ;
14991 char * kwnames[] = {
14992 (char *) "stream", NULL
14993 };
14994
14995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14996 {
14997 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14998 arg1 = temp1->m_wxis;
14999 created1 = false;
15000 } else {
15001 PyErr_Clear(); // clear the failure of the wxPyConvert above
15002 arg1 = wxPyCBInputStream_create(obj0, false);
15003 if (arg1 == NULL) {
15004 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15005 SWIG_fail;
15006 }
15007 created1 = true;
15008 }
15009 }
15010 {
15011 PyThreadState* __tstate = wxPyBeginAllowThreads();
15012 result = (bool)wxImage::CanRead(*arg1);
15013 wxPyEndAllowThreads(__tstate);
15014 if (PyErr_Occurred()) SWIG_fail;
15015 }
15016 {
15017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15018 }
15019 {
15020 if (created1) delete arg1;
15021 }
15022 return resultobj;
15023 fail:
15024 {
15025 if (created1) delete arg1;
15026 }
15027 return NULL;
15028 }
15029
15030
15031 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15032 PyObject *resultobj = 0;
15033 wxImage *arg1 = (wxImage *) 0 ;
15034 wxInputStream *arg2 = 0 ;
15035 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15036 int arg4 = (int) -1 ;
15037 bool result;
15038 void *argp1 = 0 ;
15039 int res1 = 0 ;
15040 wxPyInputStream *temp2 ;
15041 bool created2 ;
15042 long val3 ;
15043 int ecode3 = 0 ;
15044 int val4 ;
15045 int ecode4 = 0 ;
15046 PyObject * obj0 = 0 ;
15047 PyObject * obj1 = 0 ;
15048 PyObject * obj2 = 0 ;
15049 PyObject * obj3 = 0 ;
15050 char * kwnames[] = {
15051 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15052 };
15053
15054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15056 if (!SWIG_IsOK(res1)) {
15057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15058 }
15059 arg1 = reinterpret_cast< wxImage * >(argp1);
15060 {
15061 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15062 arg2 = temp2->m_wxis;
15063 created2 = false;
15064 } else {
15065 PyErr_Clear(); // clear the failure of the wxPyConvert above
15066 arg2 = wxPyCBInputStream_create(obj1, false);
15067 if (arg2 == NULL) {
15068 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15069 SWIG_fail;
15070 }
15071 created2 = true;
15072 }
15073 }
15074 if (obj2) {
15075 ecode3 = SWIG_AsVal_long(obj2, &val3);
15076 if (!SWIG_IsOK(ecode3)) {
15077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15078 }
15079 arg3 = static_cast< long >(val3);
15080 }
15081 if (obj3) {
15082 ecode4 = SWIG_AsVal_int(obj3, &val4);
15083 if (!SWIG_IsOK(ecode4)) {
15084 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15085 }
15086 arg4 = static_cast< int >(val4);
15087 }
15088 {
15089 PyThreadState* __tstate = wxPyBeginAllowThreads();
15090 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15091 wxPyEndAllowThreads(__tstate);
15092 if (PyErr_Occurred()) SWIG_fail;
15093 }
15094 {
15095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15096 }
15097 {
15098 if (created2) delete arg2;
15099 }
15100 return resultobj;
15101 fail:
15102 {
15103 if (created2) delete arg2;
15104 }
15105 return NULL;
15106 }
15107
15108
15109 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15110 PyObject *resultobj = 0;
15111 wxImage *arg1 = (wxImage *) 0 ;
15112 wxInputStream *arg2 = 0 ;
15113 wxString *arg3 = 0 ;
15114 int arg4 = (int) -1 ;
15115 bool result;
15116 void *argp1 = 0 ;
15117 int res1 = 0 ;
15118 wxPyInputStream *temp2 ;
15119 bool created2 ;
15120 bool temp3 = false ;
15121 int val4 ;
15122 int ecode4 = 0 ;
15123 PyObject * obj0 = 0 ;
15124 PyObject * obj1 = 0 ;
15125 PyObject * obj2 = 0 ;
15126 PyObject * obj3 = 0 ;
15127 char * kwnames[] = {
15128 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15129 };
15130
15131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15133 if (!SWIG_IsOK(res1)) {
15134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15135 }
15136 arg1 = reinterpret_cast< wxImage * >(argp1);
15137 {
15138 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15139 arg2 = temp2->m_wxis;
15140 created2 = false;
15141 } else {
15142 PyErr_Clear(); // clear the failure of the wxPyConvert above
15143 arg2 = wxPyCBInputStream_create(obj1, false);
15144 if (arg2 == NULL) {
15145 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15146 SWIG_fail;
15147 }
15148 created2 = true;
15149 }
15150 }
15151 {
15152 arg3 = wxString_in_helper(obj2);
15153 if (arg3 == NULL) SWIG_fail;
15154 temp3 = true;
15155 }
15156 if (obj3) {
15157 ecode4 = SWIG_AsVal_int(obj3, &val4);
15158 if (!SWIG_IsOK(ecode4)) {
15159 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15160 }
15161 arg4 = static_cast< int >(val4);
15162 }
15163 {
15164 PyThreadState* __tstate = wxPyBeginAllowThreads();
15165 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15166 wxPyEndAllowThreads(__tstate);
15167 if (PyErr_Occurred()) SWIG_fail;
15168 }
15169 {
15170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15171 }
15172 {
15173 if (created2) delete arg2;
15174 }
15175 {
15176 if (temp3)
15177 delete arg3;
15178 }
15179 return resultobj;
15180 fail:
15181 {
15182 if (created2) delete arg2;
15183 }
15184 {
15185 if (temp3)
15186 delete arg3;
15187 }
15188 return NULL;
15189 }
15190
15191
15192 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15193 PyObject *resultobj = 0;
15194 wxImage *arg1 = (wxImage *) 0 ;
15195 bool result;
15196 void *argp1 = 0 ;
15197 int res1 = 0 ;
15198 PyObject *swig_obj[1] ;
15199
15200 if (!args) SWIG_fail;
15201 swig_obj[0] = args;
15202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15203 if (!SWIG_IsOK(res1)) {
15204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15205 }
15206 arg1 = reinterpret_cast< wxImage * >(argp1);
15207 {
15208 PyThreadState* __tstate = wxPyBeginAllowThreads();
15209 result = (bool)(arg1)->Ok();
15210 wxPyEndAllowThreads(__tstate);
15211 if (PyErr_Occurred()) SWIG_fail;
15212 }
15213 {
15214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15215 }
15216 return resultobj;
15217 fail:
15218 return NULL;
15219 }
15220
15221
15222 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15223 PyObject *resultobj = 0;
15224 wxImage *arg1 = (wxImage *) 0 ;
15225 int result;
15226 void *argp1 = 0 ;
15227 int res1 = 0 ;
15228 PyObject *swig_obj[1] ;
15229
15230 if (!args) SWIG_fail;
15231 swig_obj[0] = args;
15232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15233 if (!SWIG_IsOK(res1)) {
15234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15235 }
15236 arg1 = reinterpret_cast< wxImage * >(argp1);
15237 {
15238 PyThreadState* __tstate = wxPyBeginAllowThreads();
15239 result = (int)(arg1)->GetWidth();
15240 wxPyEndAllowThreads(__tstate);
15241 if (PyErr_Occurred()) SWIG_fail;
15242 }
15243 resultobj = SWIG_From_int(static_cast< int >(result));
15244 return resultobj;
15245 fail:
15246 return NULL;
15247 }
15248
15249
15250 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15251 PyObject *resultobj = 0;
15252 wxImage *arg1 = (wxImage *) 0 ;
15253 int result;
15254 void *argp1 = 0 ;
15255 int res1 = 0 ;
15256 PyObject *swig_obj[1] ;
15257
15258 if (!args) SWIG_fail;
15259 swig_obj[0] = args;
15260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15261 if (!SWIG_IsOK(res1)) {
15262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15263 }
15264 arg1 = reinterpret_cast< wxImage * >(argp1);
15265 {
15266 PyThreadState* __tstate = wxPyBeginAllowThreads();
15267 result = (int)(arg1)->GetHeight();
15268 wxPyEndAllowThreads(__tstate);
15269 if (PyErr_Occurred()) SWIG_fail;
15270 }
15271 resultobj = SWIG_From_int(static_cast< int >(result));
15272 return resultobj;
15273 fail:
15274 return NULL;
15275 }
15276
15277
15278 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15279 PyObject *resultobj = 0;
15280 wxImage *arg1 = (wxImage *) 0 ;
15281 wxSize result;
15282 void *argp1 = 0 ;
15283 int res1 = 0 ;
15284 PyObject *swig_obj[1] ;
15285
15286 if (!args) SWIG_fail;
15287 swig_obj[0] = args;
15288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15289 if (!SWIG_IsOK(res1)) {
15290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15291 }
15292 arg1 = reinterpret_cast< wxImage * >(argp1);
15293 {
15294 PyThreadState* __tstate = wxPyBeginAllowThreads();
15295 result = wxImage_GetSize(arg1);
15296 wxPyEndAllowThreads(__tstate);
15297 if (PyErr_Occurred()) SWIG_fail;
15298 }
15299 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15300 return resultobj;
15301 fail:
15302 return NULL;
15303 }
15304
15305
15306 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15307 PyObject *resultobj = 0;
15308 wxImage *arg1 = (wxImage *) 0 ;
15309 wxRect *arg2 = 0 ;
15310 SwigValueWrapper<wxImage > result;
15311 void *argp1 = 0 ;
15312 int res1 = 0 ;
15313 wxRect temp2 ;
15314 PyObject * obj0 = 0 ;
15315 PyObject * obj1 = 0 ;
15316 char * kwnames[] = {
15317 (char *) "self",(char *) "rect", NULL
15318 };
15319
15320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15322 if (!SWIG_IsOK(res1)) {
15323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15324 }
15325 arg1 = reinterpret_cast< wxImage * >(argp1);
15326 {
15327 arg2 = &temp2;
15328 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15329 }
15330 {
15331 PyThreadState* __tstate = wxPyBeginAllowThreads();
15332 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15333 wxPyEndAllowThreads(__tstate);
15334 if (PyErr_Occurred()) SWIG_fail;
15335 }
15336 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15337 return resultobj;
15338 fail:
15339 return NULL;
15340 }
15341
15342
15343 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15344 PyObject *resultobj = 0;
15345 wxImage *arg1 = (wxImage *) 0 ;
15346 wxSize *arg2 = 0 ;
15347 wxPoint *arg3 = 0 ;
15348 int arg4 = (int) -1 ;
15349 int arg5 = (int) -1 ;
15350 int arg6 = (int) -1 ;
15351 SwigValueWrapper<wxImage > result;
15352 void *argp1 = 0 ;
15353 int res1 = 0 ;
15354 wxSize temp2 ;
15355 wxPoint temp3 ;
15356 int val4 ;
15357 int ecode4 = 0 ;
15358 int val5 ;
15359 int ecode5 = 0 ;
15360 int val6 ;
15361 int ecode6 = 0 ;
15362 PyObject * obj0 = 0 ;
15363 PyObject * obj1 = 0 ;
15364 PyObject * obj2 = 0 ;
15365 PyObject * obj3 = 0 ;
15366 PyObject * obj4 = 0 ;
15367 PyObject * obj5 = 0 ;
15368 char * kwnames[] = {
15369 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15370 };
15371
15372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15374 if (!SWIG_IsOK(res1)) {
15375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15376 }
15377 arg1 = reinterpret_cast< wxImage * >(argp1);
15378 {
15379 arg2 = &temp2;
15380 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15381 }
15382 {
15383 arg3 = &temp3;
15384 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15385 }
15386 if (obj3) {
15387 ecode4 = SWIG_AsVal_int(obj3, &val4);
15388 if (!SWIG_IsOK(ecode4)) {
15389 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15390 }
15391 arg4 = static_cast< int >(val4);
15392 }
15393 if (obj4) {
15394 ecode5 = SWIG_AsVal_int(obj4, &val5);
15395 if (!SWIG_IsOK(ecode5)) {
15396 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15397 }
15398 arg5 = static_cast< int >(val5);
15399 }
15400 if (obj5) {
15401 ecode6 = SWIG_AsVal_int(obj5, &val6);
15402 if (!SWIG_IsOK(ecode6)) {
15403 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15404 }
15405 arg6 = static_cast< int >(val6);
15406 }
15407 {
15408 PyThreadState* __tstate = wxPyBeginAllowThreads();
15409 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15410 wxPyEndAllowThreads(__tstate);
15411 if (PyErr_Occurred()) SWIG_fail;
15412 }
15413 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15414 return resultobj;
15415 fail:
15416 return NULL;
15417 }
15418
15419
15420 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15421 PyObject *resultobj = 0;
15422 wxImage *arg1 = (wxImage *) 0 ;
15423 SwigValueWrapper<wxImage > result;
15424 void *argp1 = 0 ;
15425 int res1 = 0 ;
15426 PyObject *swig_obj[1] ;
15427
15428 if (!args) SWIG_fail;
15429 swig_obj[0] = args;
15430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15431 if (!SWIG_IsOK(res1)) {
15432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15433 }
15434 arg1 = reinterpret_cast< wxImage * >(argp1);
15435 {
15436 PyThreadState* __tstate = wxPyBeginAllowThreads();
15437 result = (arg1)->Copy();
15438 wxPyEndAllowThreads(__tstate);
15439 if (PyErr_Occurred()) SWIG_fail;
15440 }
15441 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15442 return resultobj;
15443 fail:
15444 return NULL;
15445 }
15446
15447
15448 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15449 PyObject *resultobj = 0;
15450 wxImage *arg1 = (wxImage *) 0 ;
15451 wxImage *arg2 = 0 ;
15452 int arg3 ;
15453 int arg4 ;
15454 void *argp1 = 0 ;
15455 int res1 = 0 ;
15456 void *argp2 = 0 ;
15457 int res2 = 0 ;
15458 int val3 ;
15459 int ecode3 = 0 ;
15460 int val4 ;
15461 int ecode4 = 0 ;
15462 PyObject * obj0 = 0 ;
15463 PyObject * obj1 = 0 ;
15464 PyObject * obj2 = 0 ;
15465 PyObject * obj3 = 0 ;
15466 char * kwnames[] = {
15467 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15468 };
15469
15470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15472 if (!SWIG_IsOK(res1)) {
15473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15474 }
15475 arg1 = reinterpret_cast< wxImage * >(argp1);
15476 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15477 if (!SWIG_IsOK(res2)) {
15478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15479 }
15480 if (!argp2) {
15481 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15482 }
15483 arg2 = reinterpret_cast< wxImage * >(argp2);
15484 ecode3 = SWIG_AsVal_int(obj2, &val3);
15485 if (!SWIG_IsOK(ecode3)) {
15486 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15487 }
15488 arg3 = static_cast< int >(val3);
15489 ecode4 = SWIG_AsVal_int(obj3, &val4);
15490 if (!SWIG_IsOK(ecode4)) {
15491 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15492 }
15493 arg4 = static_cast< int >(val4);
15494 {
15495 PyThreadState* __tstate = wxPyBeginAllowThreads();
15496 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15497 wxPyEndAllowThreads(__tstate);
15498 if (PyErr_Occurred()) SWIG_fail;
15499 }
15500 resultobj = SWIG_Py_Void();
15501 return resultobj;
15502 fail:
15503 return NULL;
15504 }
15505
15506
15507 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15508 PyObject *resultobj = 0;
15509 wxImage *arg1 = (wxImage *) 0 ;
15510 PyObject *result = 0 ;
15511 void *argp1 = 0 ;
15512 int res1 = 0 ;
15513 PyObject *swig_obj[1] ;
15514
15515 if (!args) SWIG_fail;
15516 swig_obj[0] = args;
15517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15518 if (!SWIG_IsOK(res1)) {
15519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15520 }
15521 arg1 = reinterpret_cast< wxImage * >(argp1);
15522 {
15523 PyThreadState* __tstate = wxPyBeginAllowThreads();
15524 result = (PyObject *)wxImage_GetData(arg1);
15525 wxPyEndAllowThreads(__tstate);
15526 if (PyErr_Occurred()) SWIG_fail;
15527 }
15528 resultobj = result;
15529 return resultobj;
15530 fail:
15531 return NULL;
15532 }
15533
15534
15535 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15536 PyObject *resultobj = 0;
15537 wxImage *arg1 = (wxImage *) 0 ;
15538 buffer arg2 ;
15539 int arg3 ;
15540 void *argp1 = 0 ;
15541 int res1 = 0 ;
15542 Py_ssize_t temp2 ;
15543 PyObject * obj0 = 0 ;
15544 PyObject * obj1 = 0 ;
15545 char * kwnames[] = {
15546 (char *) "self",(char *) "data", NULL
15547 };
15548
15549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15551 if (!SWIG_IsOK(res1)) {
15552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15553 }
15554 arg1 = reinterpret_cast< wxImage * >(argp1);
15555 {
15556 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15557 arg3 = (int)temp2;
15558 }
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 wxImage_SetData(arg1,arg2,arg3);
15562 wxPyEndAllowThreads(__tstate);
15563 if (PyErr_Occurred()) SWIG_fail;
15564 }
15565 resultobj = SWIG_Py_Void();
15566 return resultobj;
15567 fail:
15568 return NULL;
15569 }
15570
15571
15572 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15573 PyObject *resultobj = 0;
15574 wxImage *arg1 = (wxImage *) 0 ;
15575 PyObject *result = 0 ;
15576 void *argp1 = 0 ;
15577 int res1 = 0 ;
15578 PyObject *swig_obj[1] ;
15579
15580 if (!args) SWIG_fail;
15581 swig_obj[0] = args;
15582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15583 if (!SWIG_IsOK(res1)) {
15584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15585 }
15586 arg1 = reinterpret_cast< wxImage * >(argp1);
15587 {
15588 PyThreadState* __tstate = wxPyBeginAllowThreads();
15589 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15590 wxPyEndAllowThreads(__tstate);
15591 if (PyErr_Occurred()) SWIG_fail;
15592 }
15593 resultobj = result;
15594 return resultobj;
15595 fail:
15596 return NULL;
15597 }
15598
15599
15600 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15601 PyObject *resultobj = 0;
15602 wxImage *arg1 = (wxImage *) 0 ;
15603 buffer arg2 ;
15604 int arg3 ;
15605 void *argp1 = 0 ;
15606 int res1 = 0 ;
15607 Py_ssize_t temp2 ;
15608 PyObject * obj0 = 0 ;
15609 PyObject * obj1 = 0 ;
15610 char * kwnames[] = {
15611 (char *) "self",(char *) "data", NULL
15612 };
15613
15614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15616 if (!SWIG_IsOK(res1)) {
15617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15618 }
15619 arg1 = reinterpret_cast< wxImage * >(argp1);
15620 {
15621 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15622 arg3 = (int)temp2;
15623 }
15624 {
15625 PyThreadState* __tstate = wxPyBeginAllowThreads();
15626 wxImage_SetDataBuffer(arg1,arg2,arg3);
15627 wxPyEndAllowThreads(__tstate);
15628 if (PyErr_Occurred()) SWIG_fail;
15629 }
15630 resultobj = SWIG_Py_Void();
15631 return resultobj;
15632 fail:
15633 return NULL;
15634 }
15635
15636
15637 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15638 PyObject *resultobj = 0;
15639 wxImage *arg1 = (wxImage *) 0 ;
15640 PyObject *result = 0 ;
15641 void *argp1 = 0 ;
15642 int res1 = 0 ;
15643 PyObject *swig_obj[1] ;
15644
15645 if (!args) SWIG_fail;
15646 swig_obj[0] = args;
15647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15648 if (!SWIG_IsOK(res1)) {
15649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15650 }
15651 arg1 = reinterpret_cast< wxImage * >(argp1);
15652 {
15653 PyThreadState* __tstate = wxPyBeginAllowThreads();
15654 result = (PyObject *)wxImage_GetAlphaData(arg1);
15655 wxPyEndAllowThreads(__tstate);
15656 if (PyErr_Occurred()) SWIG_fail;
15657 }
15658 resultobj = result;
15659 return resultobj;
15660 fail:
15661 return NULL;
15662 }
15663
15664
15665 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15666 PyObject *resultobj = 0;
15667 wxImage *arg1 = (wxImage *) 0 ;
15668 buffer arg2 ;
15669 int arg3 ;
15670 void *argp1 = 0 ;
15671 int res1 = 0 ;
15672 Py_ssize_t temp2 ;
15673 PyObject * obj0 = 0 ;
15674 PyObject * obj1 = 0 ;
15675 char * kwnames[] = {
15676 (char *) "self",(char *) "alpha", NULL
15677 };
15678
15679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15681 if (!SWIG_IsOK(res1)) {
15682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15683 }
15684 arg1 = reinterpret_cast< wxImage * >(argp1);
15685 {
15686 if (obj1 != Py_None) {
15687 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15688 arg3 = (int)temp2;
15689 }
15690 }
15691 {
15692 PyThreadState* __tstate = wxPyBeginAllowThreads();
15693 wxImage_SetAlphaData(arg1,arg2,arg3);
15694 wxPyEndAllowThreads(__tstate);
15695 if (PyErr_Occurred()) SWIG_fail;
15696 }
15697 resultobj = SWIG_Py_Void();
15698 return resultobj;
15699 fail:
15700 return NULL;
15701 }
15702
15703
15704 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15705 PyObject *resultobj = 0;
15706 wxImage *arg1 = (wxImage *) 0 ;
15707 PyObject *result = 0 ;
15708 void *argp1 = 0 ;
15709 int res1 = 0 ;
15710 PyObject *swig_obj[1] ;
15711
15712 if (!args) SWIG_fail;
15713 swig_obj[0] = args;
15714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15715 if (!SWIG_IsOK(res1)) {
15716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15717 }
15718 arg1 = reinterpret_cast< wxImage * >(argp1);
15719 {
15720 PyThreadState* __tstate = wxPyBeginAllowThreads();
15721 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15722 wxPyEndAllowThreads(__tstate);
15723 if (PyErr_Occurred()) SWIG_fail;
15724 }
15725 resultobj = result;
15726 return resultobj;
15727 fail:
15728 return NULL;
15729 }
15730
15731
15732 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15733 PyObject *resultobj = 0;
15734 wxImage *arg1 = (wxImage *) 0 ;
15735 buffer arg2 ;
15736 int arg3 ;
15737 void *argp1 = 0 ;
15738 int res1 = 0 ;
15739 Py_ssize_t temp2 ;
15740 PyObject * obj0 = 0 ;
15741 PyObject * obj1 = 0 ;
15742 char * kwnames[] = {
15743 (char *) "self",(char *) "alpha", NULL
15744 };
15745
15746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15748 if (!SWIG_IsOK(res1)) {
15749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15750 }
15751 arg1 = reinterpret_cast< wxImage * >(argp1);
15752 {
15753 if (obj1 != Py_None) {
15754 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15755 arg3 = (int)temp2;
15756 }
15757 }
15758 {
15759 PyThreadState* __tstate = wxPyBeginAllowThreads();
15760 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15761 wxPyEndAllowThreads(__tstate);
15762 if (PyErr_Occurred()) SWIG_fail;
15763 }
15764 resultobj = SWIG_Py_Void();
15765 return resultobj;
15766 fail:
15767 return NULL;
15768 }
15769
15770
15771 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15772 PyObject *resultobj = 0;
15773 wxImage *arg1 = (wxImage *) 0 ;
15774 byte arg2 ;
15775 byte arg3 ;
15776 byte arg4 ;
15777 void *argp1 = 0 ;
15778 int res1 = 0 ;
15779 unsigned char val2 ;
15780 int ecode2 = 0 ;
15781 unsigned char val3 ;
15782 int ecode3 = 0 ;
15783 unsigned char val4 ;
15784 int ecode4 = 0 ;
15785 PyObject * obj0 = 0 ;
15786 PyObject * obj1 = 0 ;
15787 PyObject * obj2 = 0 ;
15788 PyObject * obj3 = 0 ;
15789 char * kwnames[] = {
15790 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15791 };
15792
15793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15795 if (!SWIG_IsOK(res1)) {
15796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15797 }
15798 arg1 = reinterpret_cast< wxImage * >(argp1);
15799 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15800 if (!SWIG_IsOK(ecode2)) {
15801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15802 }
15803 arg2 = static_cast< byte >(val2);
15804 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15805 if (!SWIG_IsOK(ecode3)) {
15806 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15807 }
15808 arg3 = static_cast< byte >(val3);
15809 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15810 if (!SWIG_IsOK(ecode4)) {
15811 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15812 }
15813 arg4 = static_cast< byte >(val4);
15814 {
15815 PyThreadState* __tstate = wxPyBeginAllowThreads();
15816 (arg1)->SetMaskColour(arg2,arg3,arg4);
15817 wxPyEndAllowThreads(__tstate);
15818 if (PyErr_Occurred()) SWIG_fail;
15819 }
15820 resultobj = SWIG_Py_Void();
15821 return resultobj;
15822 fail:
15823 return NULL;
15824 }
15825
15826
15827 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15828 PyObject *resultobj = 0;
15829 wxImage *arg1 = (wxImage *) 0 ;
15830 byte *arg2 = (byte *) 0 ;
15831 byte *arg3 = (byte *) 0 ;
15832 byte *arg4 = (byte *) 0 ;
15833 void *argp1 = 0 ;
15834 int res1 = 0 ;
15835 byte temp2 ;
15836 int res2 = SWIG_TMPOBJ ;
15837 byte temp3 ;
15838 int res3 = SWIG_TMPOBJ ;
15839 byte temp4 ;
15840 int res4 = SWIG_TMPOBJ ;
15841 PyObject *swig_obj[1] ;
15842
15843 arg2 = &temp2;
15844 arg3 = &temp3;
15845 arg4 = &temp4;
15846 if (!args) SWIG_fail;
15847 swig_obj[0] = args;
15848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15849 if (!SWIG_IsOK(res1)) {
15850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15851 }
15852 arg1 = reinterpret_cast< wxImage * >(argp1);
15853 {
15854 PyThreadState* __tstate = wxPyBeginAllowThreads();
15855 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15856 wxPyEndAllowThreads(__tstate);
15857 if (PyErr_Occurred()) SWIG_fail;
15858 }
15859 resultobj = SWIG_Py_Void();
15860 if (SWIG_IsTmpObj(res2)) {
15861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15862 } else {
15863 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15865 }
15866 if (SWIG_IsTmpObj(res3)) {
15867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15868 } else {
15869 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15871 }
15872 if (SWIG_IsTmpObj(res4)) {
15873 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15874 } else {
15875 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15877 }
15878 return resultobj;
15879 fail:
15880 return NULL;
15881 }
15882
15883
15884 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15885 PyObject *resultobj = 0;
15886 wxImage *arg1 = (wxImage *) 0 ;
15887 byte result;
15888 void *argp1 = 0 ;
15889 int res1 = 0 ;
15890 PyObject *swig_obj[1] ;
15891
15892 if (!args) SWIG_fail;
15893 swig_obj[0] = args;
15894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15895 if (!SWIG_IsOK(res1)) {
15896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15897 }
15898 arg1 = reinterpret_cast< wxImage * >(argp1);
15899 {
15900 PyThreadState* __tstate = wxPyBeginAllowThreads();
15901 result = (byte)(arg1)->GetMaskRed();
15902 wxPyEndAllowThreads(__tstate);
15903 if (PyErr_Occurred()) SWIG_fail;
15904 }
15905 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15906 return resultobj;
15907 fail:
15908 return NULL;
15909 }
15910
15911
15912 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15913 PyObject *resultobj = 0;
15914 wxImage *arg1 = (wxImage *) 0 ;
15915 byte result;
15916 void *argp1 = 0 ;
15917 int res1 = 0 ;
15918 PyObject *swig_obj[1] ;
15919
15920 if (!args) SWIG_fail;
15921 swig_obj[0] = args;
15922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15923 if (!SWIG_IsOK(res1)) {
15924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15925 }
15926 arg1 = reinterpret_cast< wxImage * >(argp1);
15927 {
15928 PyThreadState* __tstate = wxPyBeginAllowThreads();
15929 result = (byte)(arg1)->GetMaskGreen();
15930 wxPyEndAllowThreads(__tstate);
15931 if (PyErr_Occurred()) SWIG_fail;
15932 }
15933 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15934 return resultobj;
15935 fail:
15936 return NULL;
15937 }
15938
15939
15940 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15941 PyObject *resultobj = 0;
15942 wxImage *arg1 = (wxImage *) 0 ;
15943 byte result;
15944 void *argp1 = 0 ;
15945 int res1 = 0 ;
15946 PyObject *swig_obj[1] ;
15947
15948 if (!args) SWIG_fail;
15949 swig_obj[0] = args;
15950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15951 if (!SWIG_IsOK(res1)) {
15952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15953 }
15954 arg1 = reinterpret_cast< wxImage * >(argp1);
15955 {
15956 PyThreadState* __tstate = wxPyBeginAllowThreads();
15957 result = (byte)(arg1)->GetMaskBlue();
15958 wxPyEndAllowThreads(__tstate);
15959 if (PyErr_Occurred()) SWIG_fail;
15960 }
15961 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15962 return resultobj;
15963 fail:
15964 return NULL;
15965 }
15966
15967
15968 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15969 PyObject *resultobj = 0;
15970 wxImage *arg1 = (wxImage *) 0 ;
15971 bool arg2 = (bool) true ;
15972 void *argp1 = 0 ;
15973 int res1 = 0 ;
15974 bool val2 ;
15975 int ecode2 = 0 ;
15976 PyObject * obj0 = 0 ;
15977 PyObject * obj1 = 0 ;
15978 char * kwnames[] = {
15979 (char *) "self",(char *) "mask", NULL
15980 };
15981
15982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15984 if (!SWIG_IsOK(res1)) {
15985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15986 }
15987 arg1 = reinterpret_cast< wxImage * >(argp1);
15988 if (obj1) {
15989 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15990 if (!SWIG_IsOK(ecode2)) {
15991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15992 }
15993 arg2 = static_cast< bool >(val2);
15994 }
15995 {
15996 PyThreadState* __tstate = wxPyBeginAllowThreads();
15997 (arg1)->SetMask(arg2);
15998 wxPyEndAllowThreads(__tstate);
15999 if (PyErr_Occurred()) SWIG_fail;
16000 }
16001 resultobj = SWIG_Py_Void();
16002 return resultobj;
16003 fail:
16004 return NULL;
16005 }
16006
16007
16008 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16009 PyObject *resultobj = 0;
16010 wxImage *arg1 = (wxImage *) 0 ;
16011 bool result;
16012 void *argp1 = 0 ;
16013 int res1 = 0 ;
16014 PyObject *swig_obj[1] ;
16015
16016 if (!args) SWIG_fail;
16017 swig_obj[0] = args;
16018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16019 if (!SWIG_IsOK(res1)) {
16020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16021 }
16022 arg1 = reinterpret_cast< wxImage * >(argp1);
16023 {
16024 PyThreadState* __tstate = wxPyBeginAllowThreads();
16025 result = (bool)(arg1)->HasMask();
16026 wxPyEndAllowThreads(__tstate);
16027 if (PyErr_Occurred()) SWIG_fail;
16028 }
16029 {
16030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16031 }
16032 return resultobj;
16033 fail:
16034 return NULL;
16035 }
16036
16037
16038 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16039 PyObject *resultobj = 0;
16040 wxImage *arg1 = (wxImage *) 0 ;
16041 double arg2 ;
16042 wxPoint *arg3 = 0 ;
16043 bool arg4 = (bool) true ;
16044 wxPoint *arg5 = (wxPoint *) NULL ;
16045 SwigValueWrapper<wxImage > result;
16046 void *argp1 = 0 ;
16047 int res1 = 0 ;
16048 double val2 ;
16049 int ecode2 = 0 ;
16050 wxPoint temp3 ;
16051 bool val4 ;
16052 int ecode4 = 0 ;
16053 void *argp5 = 0 ;
16054 int res5 = 0 ;
16055 PyObject * obj0 = 0 ;
16056 PyObject * obj1 = 0 ;
16057 PyObject * obj2 = 0 ;
16058 PyObject * obj3 = 0 ;
16059 PyObject * obj4 = 0 ;
16060 char * kwnames[] = {
16061 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16062 };
16063
16064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16066 if (!SWIG_IsOK(res1)) {
16067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16068 }
16069 arg1 = reinterpret_cast< wxImage * >(argp1);
16070 ecode2 = SWIG_AsVal_double(obj1, &val2);
16071 if (!SWIG_IsOK(ecode2)) {
16072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16073 }
16074 arg2 = static_cast< double >(val2);
16075 {
16076 arg3 = &temp3;
16077 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16078 }
16079 if (obj3) {
16080 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16081 if (!SWIG_IsOK(ecode4)) {
16082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16083 }
16084 arg4 = static_cast< bool >(val4);
16085 }
16086 if (obj4) {
16087 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16088 if (!SWIG_IsOK(res5)) {
16089 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16090 }
16091 arg5 = reinterpret_cast< wxPoint * >(argp5);
16092 }
16093 {
16094 PyThreadState* __tstate = wxPyBeginAllowThreads();
16095 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16096 wxPyEndAllowThreads(__tstate);
16097 if (PyErr_Occurred()) SWIG_fail;
16098 }
16099 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16100 return resultobj;
16101 fail:
16102 return NULL;
16103 }
16104
16105
16106 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16107 PyObject *resultobj = 0;
16108 wxImage *arg1 = (wxImage *) 0 ;
16109 bool arg2 = (bool) true ;
16110 SwigValueWrapper<wxImage > result;
16111 void *argp1 = 0 ;
16112 int res1 = 0 ;
16113 bool val2 ;
16114 int ecode2 = 0 ;
16115 PyObject * obj0 = 0 ;
16116 PyObject * obj1 = 0 ;
16117 char * kwnames[] = {
16118 (char *) "self",(char *) "clockwise", NULL
16119 };
16120
16121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16123 if (!SWIG_IsOK(res1)) {
16124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16125 }
16126 arg1 = reinterpret_cast< wxImage * >(argp1);
16127 if (obj1) {
16128 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16129 if (!SWIG_IsOK(ecode2)) {
16130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16131 }
16132 arg2 = static_cast< bool >(val2);
16133 }
16134 {
16135 PyThreadState* __tstate = wxPyBeginAllowThreads();
16136 result = (arg1)->Rotate90(arg2);
16137 wxPyEndAllowThreads(__tstate);
16138 if (PyErr_Occurred()) SWIG_fail;
16139 }
16140 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16141 return resultobj;
16142 fail:
16143 return NULL;
16144 }
16145
16146
16147 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16148 PyObject *resultobj = 0;
16149 wxImage *arg1 = (wxImage *) 0 ;
16150 bool arg2 = (bool) true ;
16151 SwigValueWrapper<wxImage > result;
16152 void *argp1 = 0 ;
16153 int res1 = 0 ;
16154 bool val2 ;
16155 int ecode2 = 0 ;
16156 PyObject * obj0 = 0 ;
16157 PyObject * obj1 = 0 ;
16158 char * kwnames[] = {
16159 (char *) "self",(char *) "horizontally", NULL
16160 };
16161
16162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16164 if (!SWIG_IsOK(res1)) {
16165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16166 }
16167 arg1 = reinterpret_cast< wxImage * >(argp1);
16168 if (obj1) {
16169 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16170 if (!SWIG_IsOK(ecode2)) {
16171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16172 }
16173 arg2 = static_cast< bool >(val2);
16174 }
16175 {
16176 PyThreadState* __tstate = wxPyBeginAllowThreads();
16177 result = (arg1)->Mirror(arg2);
16178 wxPyEndAllowThreads(__tstate);
16179 if (PyErr_Occurred()) SWIG_fail;
16180 }
16181 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16182 return resultobj;
16183 fail:
16184 return NULL;
16185 }
16186
16187
16188 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16189 PyObject *resultobj = 0;
16190 wxImage *arg1 = (wxImage *) 0 ;
16191 byte arg2 ;
16192 byte arg3 ;
16193 byte arg4 ;
16194 byte arg5 ;
16195 byte arg6 ;
16196 byte arg7 ;
16197 void *argp1 = 0 ;
16198 int res1 = 0 ;
16199 unsigned char val2 ;
16200 int ecode2 = 0 ;
16201 unsigned char val3 ;
16202 int ecode3 = 0 ;
16203 unsigned char val4 ;
16204 int ecode4 = 0 ;
16205 unsigned char val5 ;
16206 int ecode5 = 0 ;
16207 unsigned char val6 ;
16208 int ecode6 = 0 ;
16209 unsigned char val7 ;
16210 int ecode7 = 0 ;
16211 PyObject * obj0 = 0 ;
16212 PyObject * obj1 = 0 ;
16213 PyObject * obj2 = 0 ;
16214 PyObject * obj3 = 0 ;
16215 PyObject * obj4 = 0 ;
16216 PyObject * obj5 = 0 ;
16217 PyObject * obj6 = 0 ;
16218 char * kwnames[] = {
16219 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16220 };
16221
16222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16224 if (!SWIG_IsOK(res1)) {
16225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16226 }
16227 arg1 = reinterpret_cast< wxImage * >(argp1);
16228 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16229 if (!SWIG_IsOK(ecode2)) {
16230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16231 }
16232 arg2 = static_cast< byte >(val2);
16233 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16234 if (!SWIG_IsOK(ecode3)) {
16235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16236 }
16237 arg3 = static_cast< byte >(val3);
16238 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16239 if (!SWIG_IsOK(ecode4)) {
16240 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16241 }
16242 arg4 = static_cast< byte >(val4);
16243 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16244 if (!SWIG_IsOK(ecode5)) {
16245 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16246 }
16247 arg5 = static_cast< byte >(val5);
16248 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16249 if (!SWIG_IsOK(ecode6)) {
16250 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16251 }
16252 arg6 = static_cast< byte >(val6);
16253 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16254 if (!SWIG_IsOK(ecode7)) {
16255 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16256 }
16257 arg7 = static_cast< byte >(val7);
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 resultobj = SWIG_Py_Void();
16265 return resultobj;
16266 fail:
16267 return NULL;
16268 }
16269
16270
16271 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16272 PyObject *resultobj = 0;
16273 wxImage *arg1 = (wxImage *) 0 ;
16274 double arg2 = (double) 0.299 ;
16275 double arg3 = (double) 0.587 ;
16276 double arg4 = (double) 0.114 ;
16277 SwigValueWrapper<wxImage > result;
16278 void *argp1 = 0 ;
16279 int res1 = 0 ;
16280 double val2 ;
16281 int ecode2 = 0 ;
16282 double val3 ;
16283 int ecode3 = 0 ;
16284 double val4 ;
16285 int ecode4 = 0 ;
16286 PyObject * obj0 = 0 ;
16287 PyObject * obj1 = 0 ;
16288 PyObject * obj2 = 0 ;
16289 PyObject * obj3 = 0 ;
16290 char * kwnames[] = {
16291 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16292 };
16293
16294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16296 if (!SWIG_IsOK(res1)) {
16297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16298 }
16299 arg1 = reinterpret_cast< wxImage * >(argp1);
16300 if (obj1) {
16301 ecode2 = SWIG_AsVal_double(obj1, &val2);
16302 if (!SWIG_IsOK(ecode2)) {
16303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16304 }
16305 arg2 = static_cast< double >(val2);
16306 }
16307 if (obj2) {
16308 ecode3 = SWIG_AsVal_double(obj2, &val3);
16309 if (!SWIG_IsOK(ecode3)) {
16310 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16311 }
16312 arg3 = static_cast< double >(val3);
16313 }
16314 if (obj3) {
16315 ecode4 = SWIG_AsVal_double(obj3, &val4);
16316 if (!SWIG_IsOK(ecode4)) {
16317 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16318 }
16319 arg4 = static_cast< double >(val4);
16320 }
16321 {
16322 PyThreadState* __tstate = wxPyBeginAllowThreads();
16323 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16324 wxPyEndAllowThreads(__tstate);
16325 if (PyErr_Occurred()) SWIG_fail;
16326 }
16327 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16328 return resultobj;
16329 fail:
16330 return NULL;
16331 }
16332
16333
16334 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16335 PyObject *resultobj = 0;
16336 wxImage *arg1 = (wxImage *) 0 ;
16337 byte arg2 ;
16338 byte arg3 ;
16339 byte arg4 ;
16340 SwigValueWrapper<wxImage > result;
16341 void *argp1 = 0 ;
16342 int res1 = 0 ;
16343 unsigned char val2 ;
16344 int ecode2 = 0 ;
16345 unsigned char val3 ;
16346 int ecode3 = 0 ;
16347 unsigned char val4 ;
16348 int ecode4 = 0 ;
16349 PyObject * obj0 = 0 ;
16350 PyObject * obj1 = 0 ;
16351 PyObject * obj2 = 0 ;
16352 PyObject * obj3 = 0 ;
16353 char * kwnames[] = {
16354 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16355 };
16356
16357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16359 if (!SWIG_IsOK(res1)) {
16360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16361 }
16362 arg1 = reinterpret_cast< wxImage * >(argp1);
16363 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16364 if (!SWIG_IsOK(ecode2)) {
16365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16366 }
16367 arg2 = static_cast< byte >(val2);
16368 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16369 if (!SWIG_IsOK(ecode3)) {
16370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16371 }
16372 arg3 = static_cast< byte >(val3);
16373 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16374 if (!SWIG_IsOK(ecode4)) {
16375 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16376 }
16377 arg4 = static_cast< byte >(val4);
16378 {
16379 PyThreadState* __tstate = wxPyBeginAllowThreads();
16380 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16381 wxPyEndAllowThreads(__tstate);
16382 if (PyErr_Occurred()) SWIG_fail;
16383 }
16384 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16385 return resultobj;
16386 fail:
16387 return NULL;
16388 }
16389
16390
16391 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16392 PyObject *resultobj = 0;
16393 wxImage *arg1 = (wxImage *) 0 ;
16394 wxString *arg2 = 0 ;
16395 wxString *arg3 = 0 ;
16396 void *argp1 = 0 ;
16397 int res1 = 0 ;
16398 bool temp2 = false ;
16399 bool temp3 = false ;
16400 PyObject * obj0 = 0 ;
16401 PyObject * obj1 = 0 ;
16402 PyObject * obj2 = 0 ;
16403 char * kwnames[] = {
16404 (char *) "self",(char *) "name",(char *) "value", NULL
16405 };
16406
16407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16409 if (!SWIG_IsOK(res1)) {
16410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16411 }
16412 arg1 = reinterpret_cast< wxImage * >(argp1);
16413 {
16414 arg2 = wxString_in_helper(obj1);
16415 if (arg2 == NULL) SWIG_fail;
16416 temp2 = true;
16417 }
16418 {
16419 arg3 = wxString_in_helper(obj2);
16420 if (arg3 == NULL) SWIG_fail;
16421 temp3 = true;
16422 }
16423 {
16424 PyThreadState* __tstate = wxPyBeginAllowThreads();
16425 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16426 wxPyEndAllowThreads(__tstate);
16427 if (PyErr_Occurred()) SWIG_fail;
16428 }
16429 resultobj = SWIG_Py_Void();
16430 {
16431 if (temp2)
16432 delete arg2;
16433 }
16434 {
16435 if (temp3)
16436 delete arg3;
16437 }
16438 return resultobj;
16439 fail:
16440 {
16441 if (temp2)
16442 delete arg2;
16443 }
16444 {
16445 if (temp3)
16446 delete arg3;
16447 }
16448 return NULL;
16449 }
16450
16451
16452 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16453 PyObject *resultobj = 0;
16454 wxImage *arg1 = (wxImage *) 0 ;
16455 wxString *arg2 = 0 ;
16456 int arg3 ;
16457 void *argp1 = 0 ;
16458 int res1 = 0 ;
16459 bool temp2 = false ;
16460 int val3 ;
16461 int ecode3 = 0 ;
16462 PyObject * obj0 = 0 ;
16463 PyObject * obj1 = 0 ;
16464 PyObject * obj2 = 0 ;
16465 char * kwnames[] = {
16466 (char *) "self",(char *) "name",(char *) "value", NULL
16467 };
16468
16469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16471 if (!SWIG_IsOK(res1)) {
16472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16473 }
16474 arg1 = reinterpret_cast< wxImage * >(argp1);
16475 {
16476 arg2 = wxString_in_helper(obj1);
16477 if (arg2 == NULL) SWIG_fail;
16478 temp2 = true;
16479 }
16480 ecode3 = SWIG_AsVal_int(obj2, &val3);
16481 if (!SWIG_IsOK(ecode3)) {
16482 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16483 }
16484 arg3 = static_cast< int >(val3);
16485 {
16486 PyThreadState* __tstate = wxPyBeginAllowThreads();
16487 (arg1)->SetOption((wxString const &)*arg2,arg3);
16488 wxPyEndAllowThreads(__tstate);
16489 if (PyErr_Occurred()) SWIG_fail;
16490 }
16491 resultobj = SWIG_Py_Void();
16492 {
16493 if (temp2)
16494 delete arg2;
16495 }
16496 return resultobj;
16497 fail:
16498 {
16499 if (temp2)
16500 delete arg2;
16501 }
16502 return NULL;
16503 }
16504
16505
16506 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16507 PyObject *resultobj = 0;
16508 wxImage *arg1 = (wxImage *) 0 ;
16509 wxString *arg2 = 0 ;
16510 wxString result;
16511 void *argp1 = 0 ;
16512 int res1 = 0 ;
16513 bool temp2 = false ;
16514 PyObject * obj0 = 0 ;
16515 PyObject * obj1 = 0 ;
16516 char * kwnames[] = {
16517 (char *) "self",(char *) "name", NULL
16518 };
16519
16520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16522 if (!SWIG_IsOK(res1)) {
16523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16524 }
16525 arg1 = reinterpret_cast< wxImage * >(argp1);
16526 {
16527 arg2 = wxString_in_helper(obj1);
16528 if (arg2 == NULL) SWIG_fail;
16529 temp2 = true;
16530 }
16531 {
16532 PyThreadState* __tstate = wxPyBeginAllowThreads();
16533 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16534 wxPyEndAllowThreads(__tstate);
16535 if (PyErr_Occurred()) SWIG_fail;
16536 }
16537 {
16538 #if wxUSE_UNICODE
16539 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16540 #else
16541 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16542 #endif
16543 }
16544 {
16545 if (temp2)
16546 delete arg2;
16547 }
16548 return resultobj;
16549 fail:
16550 {
16551 if (temp2)
16552 delete arg2;
16553 }
16554 return NULL;
16555 }
16556
16557
16558 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16559 PyObject *resultobj = 0;
16560 wxImage *arg1 = (wxImage *) 0 ;
16561 wxString *arg2 = 0 ;
16562 int result;
16563 void *argp1 = 0 ;
16564 int res1 = 0 ;
16565 bool temp2 = false ;
16566 PyObject * obj0 = 0 ;
16567 PyObject * obj1 = 0 ;
16568 char * kwnames[] = {
16569 (char *) "self",(char *) "name", NULL
16570 };
16571
16572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16574 if (!SWIG_IsOK(res1)) {
16575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16576 }
16577 arg1 = reinterpret_cast< wxImage * >(argp1);
16578 {
16579 arg2 = wxString_in_helper(obj1);
16580 if (arg2 == NULL) SWIG_fail;
16581 temp2 = true;
16582 }
16583 {
16584 PyThreadState* __tstate = wxPyBeginAllowThreads();
16585 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 resultobj = SWIG_From_int(static_cast< int >(result));
16590 {
16591 if (temp2)
16592 delete arg2;
16593 }
16594 return resultobj;
16595 fail:
16596 {
16597 if (temp2)
16598 delete arg2;
16599 }
16600 return NULL;
16601 }
16602
16603
16604 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16605 PyObject *resultobj = 0;
16606 wxImage *arg1 = (wxImage *) 0 ;
16607 wxString *arg2 = 0 ;
16608 bool result;
16609 void *argp1 = 0 ;
16610 int res1 = 0 ;
16611 bool temp2 = false ;
16612 PyObject * obj0 = 0 ;
16613 PyObject * obj1 = 0 ;
16614 char * kwnames[] = {
16615 (char *) "self",(char *) "name", NULL
16616 };
16617
16618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16620 if (!SWIG_IsOK(res1)) {
16621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16622 }
16623 arg1 = reinterpret_cast< wxImage * >(argp1);
16624 {
16625 arg2 = wxString_in_helper(obj1);
16626 if (arg2 == NULL) SWIG_fail;
16627 temp2 = true;
16628 }
16629 {
16630 PyThreadState* __tstate = wxPyBeginAllowThreads();
16631 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16632 wxPyEndAllowThreads(__tstate);
16633 if (PyErr_Occurred()) SWIG_fail;
16634 }
16635 {
16636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16637 }
16638 {
16639 if (temp2)
16640 delete arg2;
16641 }
16642 return resultobj;
16643 fail:
16644 {
16645 if (temp2)
16646 delete arg2;
16647 }
16648 return NULL;
16649 }
16650
16651
16652 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16653 PyObject *resultobj = 0;
16654 wxImage *arg1 = (wxImage *) 0 ;
16655 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16656 unsigned long result;
16657 void *argp1 = 0 ;
16658 int res1 = 0 ;
16659 unsigned long val2 ;
16660 int ecode2 = 0 ;
16661 PyObject * obj0 = 0 ;
16662 PyObject * obj1 = 0 ;
16663 char * kwnames[] = {
16664 (char *) "self",(char *) "stopafter", NULL
16665 };
16666
16667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16669 if (!SWIG_IsOK(res1)) {
16670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16671 }
16672 arg1 = reinterpret_cast< wxImage * >(argp1);
16673 if (obj1) {
16674 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16675 if (!SWIG_IsOK(ecode2)) {
16676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16677 }
16678 arg2 = static_cast< unsigned long >(val2);
16679 }
16680 {
16681 PyThreadState* __tstate = wxPyBeginAllowThreads();
16682 result = (unsigned long)(arg1)->CountColours(arg2);
16683 wxPyEndAllowThreads(__tstate);
16684 if (PyErr_Occurred()) SWIG_fail;
16685 }
16686 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16687 return resultobj;
16688 fail:
16689 return NULL;
16690 }
16691
16692
16693 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16694 PyObject *resultobj = 0;
16695 wxImage *arg1 = (wxImage *) 0 ;
16696 wxImageHistogram *arg2 = 0 ;
16697 unsigned long result;
16698 void *argp1 = 0 ;
16699 int res1 = 0 ;
16700 void *argp2 = 0 ;
16701 int res2 = 0 ;
16702 PyObject * obj0 = 0 ;
16703 PyObject * obj1 = 0 ;
16704 char * kwnames[] = {
16705 (char *) "self",(char *) "h", NULL
16706 };
16707
16708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16710 if (!SWIG_IsOK(res1)) {
16711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16712 }
16713 arg1 = reinterpret_cast< wxImage * >(argp1);
16714 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16715 if (!SWIG_IsOK(res2)) {
16716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16717 }
16718 if (!argp2) {
16719 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16720 }
16721 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16722 {
16723 PyThreadState* __tstate = wxPyBeginAllowThreads();
16724 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16725 wxPyEndAllowThreads(__tstate);
16726 if (PyErr_Occurred()) SWIG_fail;
16727 }
16728 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16729 return resultobj;
16730 fail:
16731 return NULL;
16732 }
16733
16734
16735 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16736 PyObject *resultobj = 0;
16737 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16738 void *argp1 = 0 ;
16739 int res1 = 0 ;
16740 PyObject * obj0 = 0 ;
16741 char * kwnames[] = {
16742 (char *) "handler", NULL
16743 };
16744
16745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16747 if (!SWIG_IsOK(res1)) {
16748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16749 }
16750 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16751 {
16752 PyThreadState* __tstate = wxPyBeginAllowThreads();
16753 wxImage::AddHandler(arg1);
16754 wxPyEndAllowThreads(__tstate);
16755 if (PyErr_Occurred()) SWIG_fail;
16756 }
16757 resultobj = SWIG_Py_Void();
16758 return resultobj;
16759 fail:
16760 return NULL;
16761 }
16762
16763
16764 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16765 PyObject *resultobj = 0;
16766 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16767 void *argp1 = 0 ;
16768 int res1 = 0 ;
16769 PyObject * obj0 = 0 ;
16770 char * kwnames[] = {
16771 (char *) "handler", NULL
16772 };
16773
16774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16776 if (!SWIG_IsOK(res1)) {
16777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16778 }
16779 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16780 {
16781 PyThreadState* __tstate = wxPyBeginAllowThreads();
16782 wxImage::InsertHandler(arg1);
16783 wxPyEndAllowThreads(__tstate);
16784 if (PyErr_Occurred()) SWIG_fail;
16785 }
16786 resultobj = SWIG_Py_Void();
16787 return resultobj;
16788 fail:
16789 return NULL;
16790 }
16791
16792
16793 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16794 PyObject *resultobj = 0;
16795 wxString *arg1 = 0 ;
16796 bool result;
16797 bool temp1 = false ;
16798 PyObject * obj0 = 0 ;
16799 char * kwnames[] = {
16800 (char *) "name", NULL
16801 };
16802
16803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16804 {
16805 arg1 = wxString_in_helper(obj0);
16806 if (arg1 == NULL) SWIG_fail;
16807 temp1 = true;
16808 }
16809 {
16810 PyThreadState* __tstate = wxPyBeginAllowThreads();
16811 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16812 wxPyEndAllowThreads(__tstate);
16813 if (PyErr_Occurred()) SWIG_fail;
16814 }
16815 {
16816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16817 }
16818 {
16819 if (temp1)
16820 delete arg1;
16821 }
16822 return resultobj;
16823 fail:
16824 {
16825 if (temp1)
16826 delete arg1;
16827 }
16828 return NULL;
16829 }
16830
16831
16832 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16833 PyObject *resultobj = 0;
16834 PyObject *result = 0 ;
16835
16836 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16837 {
16838 PyThreadState* __tstate = wxPyBeginAllowThreads();
16839 result = (PyObject *)wxImage_GetHandlers();
16840 wxPyEndAllowThreads(__tstate);
16841 if (PyErr_Occurred()) SWIG_fail;
16842 }
16843 resultobj = result;
16844 return resultobj;
16845 fail:
16846 return NULL;
16847 }
16848
16849
16850 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16851 PyObject *resultobj = 0;
16852 wxString result;
16853
16854 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16855 {
16856 PyThreadState* __tstate = wxPyBeginAllowThreads();
16857 result = wxImage::GetImageExtWildcard();
16858 wxPyEndAllowThreads(__tstate);
16859 if (PyErr_Occurred()) SWIG_fail;
16860 }
16861 {
16862 #if wxUSE_UNICODE
16863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16864 #else
16865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16866 #endif
16867 }
16868 return resultobj;
16869 fail:
16870 return NULL;
16871 }
16872
16873
16874 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16875 PyObject *resultobj = 0;
16876 wxImage *arg1 = (wxImage *) 0 ;
16877 int arg2 = (int) -1 ;
16878 wxBitmap result;
16879 void *argp1 = 0 ;
16880 int res1 = 0 ;
16881 int val2 ;
16882 int ecode2 = 0 ;
16883 PyObject * obj0 = 0 ;
16884 PyObject * obj1 = 0 ;
16885 char * kwnames[] = {
16886 (char *) "self",(char *) "depth", NULL
16887 };
16888
16889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16891 if (!SWIG_IsOK(res1)) {
16892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16893 }
16894 arg1 = reinterpret_cast< wxImage * >(argp1);
16895 if (obj1) {
16896 ecode2 = SWIG_AsVal_int(obj1, &val2);
16897 if (!SWIG_IsOK(ecode2)) {
16898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16899 }
16900 arg2 = static_cast< int >(val2);
16901 }
16902 {
16903 if (!wxPyCheckForApp()) SWIG_fail;
16904 PyThreadState* __tstate = wxPyBeginAllowThreads();
16905 result = wxImage_ConvertToBitmap(arg1,arg2);
16906 wxPyEndAllowThreads(__tstate);
16907 if (PyErr_Occurred()) SWIG_fail;
16908 }
16909 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16910 return resultobj;
16911 fail:
16912 return NULL;
16913 }
16914
16915
16916 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16917 PyObject *resultobj = 0;
16918 wxImage *arg1 = (wxImage *) 0 ;
16919 byte arg2 ;
16920 byte arg3 ;
16921 byte arg4 ;
16922 wxBitmap result;
16923 void *argp1 = 0 ;
16924 int res1 = 0 ;
16925 unsigned char val2 ;
16926 int ecode2 = 0 ;
16927 unsigned char val3 ;
16928 int ecode3 = 0 ;
16929 unsigned char val4 ;
16930 int ecode4 = 0 ;
16931 PyObject * obj0 = 0 ;
16932 PyObject * obj1 = 0 ;
16933 PyObject * obj2 = 0 ;
16934 PyObject * obj3 = 0 ;
16935 char * kwnames[] = {
16936 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16937 };
16938
16939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16941 if (!SWIG_IsOK(res1)) {
16942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16943 }
16944 arg1 = reinterpret_cast< wxImage * >(argp1);
16945 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16946 if (!SWIG_IsOK(ecode2)) {
16947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16948 }
16949 arg2 = static_cast< byte >(val2);
16950 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16951 if (!SWIG_IsOK(ecode3)) {
16952 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16953 }
16954 arg3 = static_cast< byte >(val3);
16955 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16956 if (!SWIG_IsOK(ecode4)) {
16957 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16958 }
16959 arg4 = static_cast< byte >(val4);
16960 {
16961 if (!wxPyCheckForApp()) SWIG_fail;
16962 PyThreadState* __tstate = wxPyBeginAllowThreads();
16963 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16964 wxPyEndAllowThreads(__tstate);
16965 if (PyErr_Occurred()) SWIG_fail;
16966 }
16967 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16968 return resultobj;
16969 fail:
16970 return NULL;
16971 }
16972
16973
16974 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16975 PyObject *resultobj = 0;
16976 wxImage *arg1 = (wxImage *) 0 ;
16977 double arg2 ;
16978 void *argp1 = 0 ;
16979 int res1 = 0 ;
16980 double val2 ;
16981 int ecode2 = 0 ;
16982 PyObject * obj0 = 0 ;
16983 PyObject * obj1 = 0 ;
16984 char * kwnames[] = {
16985 (char *) "self",(char *) "angle", NULL
16986 };
16987
16988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16990 if (!SWIG_IsOK(res1)) {
16991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16992 }
16993 arg1 = reinterpret_cast< wxImage * >(argp1);
16994 ecode2 = SWIG_AsVal_double(obj1, &val2);
16995 if (!SWIG_IsOK(ecode2)) {
16996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16997 }
16998 arg2 = static_cast< double >(val2);
16999 {
17000 PyThreadState* __tstate = wxPyBeginAllowThreads();
17001 (arg1)->RotateHue(arg2);
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 resultobj = SWIG_Py_Void();
17006 return resultobj;
17007 fail:
17008 return NULL;
17009 }
17010
17011
17012 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17013 PyObject *resultobj = 0;
17014 wxImage_RGBValue arg1 ;
17015 wxImage_HSVValue result;
17016 void *argp1 ;
17017 int res1 = 0 ;
17018 PyObject * obj0 = 0 ;
17019 char * kwnames[] = {
17020 (char *) "rgb", NULL
17021 };
17022
17023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17024 {
17025 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17026 if (!SWIG_IsOK(res1)) {
17027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17028 }
17029 if (!argp1) {
17030 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17031 } else {
17032 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17033 arg1 = *temp;
17034 if (SWIG_IsNewObj(res1)) delete temp;
17035 }
17036 }
17037 {
17038 PyThreadState* __tstate = wxPyBeginAllowThreads();
17039 result = wxImage::RGBtoHSV(arg1);
17040 wxPyEndAllowThreads(__tstate);
17041 if (PyErr_Occurred()) SWIG_fail;
17042 }
17043 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17044 return resultobj;
17045 fail:
17046 return NULL;
17047 }
17048
17049
17050 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17051 PyObject *resultobj = 0;
17052 wxImage_HSVValue arg1 ;
17053 wxImage_RGBValue result;
17054 void *argp1 ;
17055 int res1 = 0 ;
17056 PyObject * obj0 = 0 ;
17057 char * kwnames[] = {
17058 (char *) "hsv", NULL
17059 };
17060
17061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17062 {
17063 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17064 if (!SWIG_IsOK(res1)) {
17065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17066 }
17067 if (!argp1) {
17068 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17069 } else {
17070 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17071 arg1 = *temp;
17072 if (SWIG_IsNewObj(res1)) delete temp;
17073 }
17074 }
17075 {
17076 PyThreadState* __tstate = wxPyBeginAllowThreads();
17077 result = wxImage::HSVtoRGB(arg1);
17078 wxPyEndAllowThreads(__tstate);
17079 if (PyErr_Occurred()) SWIG_fail;
17080 }
17081 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17082 return resultobj;
17083 fail:
17084 return NULL;
17085 }
17086
17087
17088 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17089 PyObject *obj;
17090 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17091 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17092 return SWIG_Py_Void();
17093 }
17094
17095 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17096 return SWIG_Python_InitShadowInstance(args);
17097 }
17098
17099 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17100 PyObject *resultobj = 0;
17101 int arg1 ;
17102 int arg2 ;
17103 buffer arg3 ;
17104 int arg4 ;
17105 buffer arg5 = (buffer) NULL ;
17106 int arg6 = (int) 0 ;
17107 wxImage *result = 0 ;
17108 int val1 ;
17109 int ecode1 = 0 ;
17110 int val2 ;
17111 int ecode2 = 0 ;
17112 Py_ssize_t temp3 ;
17113 Py_ssize_t temp5 ;
17114 PyObject * obj0 = 0 ;
17115 PyObject * obj1 = 0 ;
17116 PyObject * obj2 = 0 ;
17117 PyObject * obj3 = 0 ;
17118 char * kwnames[] = {
17119 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17120 };
17121
17122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17123 ecode1 = SWIG_AsVal_int(obj0, &val1);
17124 if (!SWIG_IsOK(ecode1)) {
17125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17126 }
17127 arg1 = static_cast< int >(val1);
17128 ecode2 = SWIG_AsVal_int(obj1, &val2);
17129 if (!SWIG_IsOK(ecode2)) {
17130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17131 }
17132 arg2 = static_cast< int >(val2);
17133 {
17134 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17135 arg4 = (int)temp3;
17136 }
17137 if (obj3) {
17138 {
17139 if (obj3 != Py_None) {
17140 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17141 arg6 = (int)temp5;
17142 }
17143 }
17144 }
17145 {
17146 PyThreadState* __tstate = wxPyBeginAllowThreads();
17147 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17148 wxPyEndAllowThreads(__tstate);
17149 if (PyErr_Occurred()) SWIG_fail;
17150 }
17151 {
17152 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17153 }
17154 return resultobj;
17155 fail:
17156 return NULL;
17157 }
17158
17159
17160 SWIGINTERN int NullImage_set(PyObject *) {
17161 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17162 return 1;
17163 }
17164
17165
17166 SWIGINTERN PyObject *NullImage_get(void) {
17167 PyObject *pyobj = 0;
17168
17169 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17170 return pyobj;
17171 }
17172
17173
17174 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17175 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17176 return 1;
17177 }
17178
17179
17180 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17181 PyObject *pyobj = 0;
17182
17183 {
17184 #if wxUSE_UNICODE
17185 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17186 #else
17187 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17188 #endif
17189 }
17190 return pyobj;
17191 }
17192
17193
17194 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17195 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17196 return 1;
17197 }
17198
17199
17200 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17201 PyObject *pyobj = 0;
17202
17203 {
17204 #if wxUSE_UNICODE
17205 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17206 #else
17207 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17208 #endif
17209 }
17210 return pyobj;
17211 }
17212
17213
17214 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17215 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17216 return 1;
17217 }
17218
17219
17220 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17221 PyObject *pyobj = 0;
17222
17223 {
17224 #if wxUSE_UNICODE
17225 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17226 #else
17227 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17228 #endif
17229 }
17230 return pyobj;
17231 }
17232
17233
17234 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17235 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17236 return 1;
17237 }
17238
17239
17240 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17241 PyObject *pyobj = 0;
17242
17243 {
17244 #if wxUSE_UNICODE
17245 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17246 #else
17247 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17248 #endif
17249 }
17250 return pyobj;
17251 }
17252
17253
17254 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17255 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17256 return 1;
17257 }
17258
17259
17260 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17261 PyObject *pyobj = 0;
17262
17263 {
17264 #if wxUSE_UNICODE
17265 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17266 #else
17267 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17268 #endif
17269 }
17270 return pyobj;
17271 }
17272
17273
17274 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17275 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17276 return 1;
17277 }
17278
17279
17280 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17281 PyObject *pyobj = 0;
17282
17283 {
17284 #if wxUSE_UNICODE
17285 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17286 #else
17287 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17288 #endif
17289 }
17290 return pyobj;
17291 }
17292
17293
17294 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17295 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17296 return 1;
17297 }
17298
17299
17300 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17301 PyObject *pyobj = 0;
17302
17303 {
17304 #if wxUSE_UNICODE
17305 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17306 #else
17307 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17308 #endif
17309 }
17310 return pyobj;
17311 }
17312
17313
17314 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17315 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17316 return 1;
17317 }
17318
17319
17320 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17321 PyObject *pyobj = 0;
17322
17323 {
17324 #if wxUSE_UNICODE
17325 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17326 #else
17327 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17328 #endif
17329 }
17330 return pyobj;
17331 }
17332
17333
17334 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17335 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17336 return 1;
17337 }
17338
17339
17340 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17341 PyObject *pyobj = 0;
17342
17343 {
17344 #if wxUSE_UNICODE
17345 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17346 #else
17347 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17348 #endif
17349 }
17350 return pyobj;
17351 }
17352
17353
17354 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17355 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17356 return 1;
17357 }
17358
17359
17360 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17361 PyObject *pyobj = 0;
17362
17363 {
17364 #if wxUSE_UNICODE
17365 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17366 #else
17367 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17368 #endif
17369 }
17370 return pyobj;
17371 }
17372
17373
17374 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17375 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17376 return 1;
17377 }
17378
17379
17380 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17381 PyObject *pyobj = 0;
17382
17383 {
17384 #if wxUSE_UNICODE
17385 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17386 #else
17387 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17388 #endif
17389 }
17390 return pyobj;
17391 }
17392
17393
17394 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17395 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17396 return 1;
17397 }
17398
17399
17400 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17401 PyObject *pyobj = 0;
17402
17403 {
17404 #if wxUSE_UNICODE
17405 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17406 #else
17407 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17408 #endif
17409 }
17410 return pyobj;
17411 }
17412
17413
17414 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17415 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17416 return 1;
17417 }
17418
17419
17420 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17421 PyObject *pyobj = 0;
17422
17423 {
17424 #if wxUSE_UNICODE
17425 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17426 #else
17427 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17428 #endif
17429 }
17430 return pyobj;
17431 }
17432
17433
17434 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17435 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17436 return 1;
17437 }
17438
17439
17440 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17441 PyObject *pyobj = 0;
17442
17443 {
17444 #if wxUSE_UNICODE
17445 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17446 #else
17447 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17448 #endif
17449 }
17450 return pyobj;
17451 }
17452
17453
17454 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17455 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17456 return 1;
17457 }
17458
17459
17460 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17461 PyObject *pyobj = 0;
17462
17463 {
17464 #if wxUSE_UNICODE
17465 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17466 #else
17467 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17468 #endif
17469 }
17470 return pyobj;
17471 }
17472
17473
17474 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17475 PyObject *resultobj = 0;
17476 wxBMPHandler *result = 0 ;
17477
17478 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (wxBMPHandler *)new wxBMPHandler();
17482 wxPyEndAllowThreads(__tstate);
17483 if (PyErr_Occurred()) SWIG_fail;
17484 }
17485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17486 return resultobj;
17487 fail:
17488 return NULL;
17489 }
17490
17491
17492 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17493 PyObject *obj;
17494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17495 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17496 return SWIG_Py_Void();
17497 }
17498
17499 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17500 return SWIG_Python_InitShadowInstance(args);
17501 }
17502
17503 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17504 PyObject *resultobj = 0;
17505 wxICOHandler *result = 0 ;
17506
17507 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17508 {
17509 PyThreadState* __tstate = wxPyBeginAllowThreads();
17510 result = (wxICOHandler *)new wxICOHandler();
17511 wxPyEndAllowThreads(__tstate);
17512 if (PyErr_Occurred()) SWIG_fail;
17513 }
17514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17515 return resultobj;
17516 fail:
17517 return NULL;
17518 }
17519
17520
17521 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17522 PyObject *obj;
17523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17524 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17525 return SWIG_Py_Void();
17526 }
17527
17528 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17529 return SWIG_Python_InitShadowInstance(args);
17530 }
17531
17532 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17533 PyObject *resultobj = 0;
17534 wxCURHandler *result = 0 ;
17535
17536 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17537 {
17538 PyThreadState* __tstate = wxPyBeginAllowThreads();
17539 result = (wxCURHandler *)new wxCURHandler();
17540 wxPyEndAllowThreads(__tstate);
17541 if (PyErr_Occurred()) SWIG_fail;
17542 }
17543 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17544 return resultobj;
17545 fail:
17546 return NULL;
17547 }
17548
17549
17550 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17551 PyObject *obj;
17552 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17553 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17554 return SWIG_Py_Void();
17555 }
17556
17557 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17558 return SWIG_Python_InitShadowInstance(args);
17559 }
17560
17561 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17562 PyObject *resultobj = 0;
17563 wxANIHandler *result = 0 ;
17564
17565 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17566 {
17567 PyThreadState* __tstate = wxPyBeginAllowThreads();
17568 result = (wxANIHandler *)new wxANIHandler();
17569 wxPyEndAllowThreads(__tstate);
17570 if (PyErr_Occurred()) SWIG_fail;
17571 }
17572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17573 return resultobj;
17574 fail:
17575 return NULL;
17576 }
17577
17578
17579 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17580 PyObject *obj;
17581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17582 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17583 return SWIG_Py_Void();
17584 }
17585
17586 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17587 return SWIG_Python_InitShadowInstance(args);
17588 }
17589
17590 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17591 PyObject *resultobj = 0;
17592 wxPNGHandler *result = 0 ;
17593
17594 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17595 {
17596 PyThreadState* __tstate = wxPyBeginAllowThreads();
17597 result = (wxPNGHandler *)new wxPNGHandler();
17598 wxPyEndAllowThreads(__tstate);
17599 if (PyErr_Occurred()) SWIG_fail;
17600 }
17601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17602 return resultobj;
17603 fail:
17604 return NULL;
17605 }
17606
17607
17608 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17609 PyObject *obj;
17610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17611 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17612 return SWIG_Py_Void();
17613 }
17614
17615 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17616 return SWIG_Python_InitShadowInstance(args);
17617 }
17618
17619 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17620 PyObject *resultobj = 0;
17621 wxGIFHandler *result = 0 ;
17622
17623 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17624 {
17625 PyThreadState* __tstate = wxPyBeginAllowThreads();
17626 result = (wxGIFHandler *)new wxGIFHandler();
17627 wxPyEndAllowThreads(__tstate);
17628 if (PyErr_Occurred()) SWIG_fail;
17629 }
17630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17631 return resultobj;
17632 fail:
17633 return NULL;
17634 }
17635
17636
17637 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17638 PyObject *obj;
17639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17640 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17641 return SWIG_Py_Void();
17642 }
17643
17644 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17645 return SWIG_Python_InitShadowInstance(args);
17646 }
17647
17648 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17649 PyObject *resultobj = 0;
17650 wxPCXHandler *result = 0 ;
17651
17652 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17653 {
17654 PyThreadState* __tstate = wxPyBeginAllowThreads();
17655 result = (wxPCXHandler *)new wxPCXHandler();
17656 wxPyEndAllowThreads(__tstate);
17657 if (PyErr_Occurred()) SWIG_fail;
17658 }
17659 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17660 return resultobj;
17661 fail:
17662 return NULL;
17663 }
17664
17665
17666 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17667 PyObject *obj;
17668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17669 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17670 return SWIG_Py_Void();
17671 }
17672
17673 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17674 return SWIG_Python_InitShadowInstance(args);
17675 }
17676
17677 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17678 PyObject *resultobj = 0;
17679 wxJPEGHandler *result = 0 ;
17680
17681 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17682 {
17683 PyThreadState* __tstate = wxPyBeginAllowThreads();
17684 result = (wxJPEGHandler *)new wxJPEGHandler();
17685 wxPyEndAllowThreads(__tstate);
17686 if (PyErr_Occurred()) SWIG_fail;
17687 }
17688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17689 return resultobj;
17690 fail:
17691 return NULL;
17692 }
17693
17694
17695 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17696 PyObject *obj;
17697 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17698 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17699 return SWIG_Py_Void();
17700 }
17701
17702 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17703 return SWIG_Python_InitShadowInstance(args);
17704 }
17705
17706 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17707 PyObject *resultobj = 0;
17708 wxPNMHandler *result = 0 ;
17709
17710 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17711 {
17712 PyThreadState* __tstate = wxPyBeginAllowThreads();
17713 result = (wxPNMHandler *)new wxPNMHandler();
17714 wxPyEndAllowThreads(__tstate);
17715 if (PyErr_Occurred()) SWIG_fail;
17716 }
17717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17718 return resultobj;
17719 fail:
17720 return NULL;
17721 }
17722
17723
17724 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17725 PyObject *obj;
17726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17727 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17728 return SWIG_Py_Void();
17729 }
17730
17731 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17732 return SWIG_Python_InitShadowInstance(args);
17733 }
17734
17735 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17736 PyObject *resultobj = 0;
17737 wxXPMHandler *result = 0 ;
17738
17739 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17740 {
17741 PyThreadState* __tstate = wxPyBeginAllowThreads();
17742 result = (wxXPMHandler *)new wxXPMHandler();
17743 wxPyEndAllowThreads(__tstate);
17744 if (PyErr_Occurred()) SWIG_fail;
17745 }
17746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17747 return resultobj;
17748 fail:
17749 return NULL;
17750 }
17751
17752
17753 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17754 PyObject *obj;
17755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17756 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17757 return SWIG_Py_Void();
17758 }
17759
17760 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17761 return SWIG_Python_InitShadowInstance(args);
17762 }
17763
17764 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17765 PyObject *resultobj = 0;
17766 wxTIFFHandler *result = 0 ;
17767
17768 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17769 {
17770 PyThreadState* __tstate = wxPyBeginAllowThreads();
17771 result = (wxTIFFHandler *)new wxTIFFHandler();
17772 wxPyEndAllowThreads(__tstate);
17773 if (PyErr_Occurred()) SWIG_fail;
17774 }
17775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17776 return resultobj;
17777 fail:
17778 return NULL;
17779 }
17780
17781
17782 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17783 PyObject *obj;
17784 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17785 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17786 return SWIG_Py_Void();
17787 }
17788
17789 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17790 return SWIG_Python_InitShadowInstance(args);
17791 }
17792
17793 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17794 PyObject *resultobj = 0;
17795 wxImage *arg1 = 0 ;
17796 wxImage *arg2 = 0 ;
17797 int arg3 = (int) 236 ;
17798 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17799 bool result;
17800 void *argp1 = 0 ;
17801 int res1 = 0 ;
17802 void *argp2 = 0 ;
17803 int res2 = 0 ;
17804 int val3 ;
17805 int ecode3 = 0 ;
17806 int val4 ;
17807 int ecode4 = 0 ;
17808 PyObject * obj0 = 0 ;
17809 PyObject * obj1 = 0 ;
17810 PyObject * obj2 = 0 ;
17811 PyObject * obj3 = 0 ;
17812 char * kwnames[] = {
17813 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17814 };
17815
17816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17817 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17818 if (!SWIG_IsOK(res1)) {
17819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17820 }
17821 if (!argp1) {
17822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17823 }
17824 arg1 = reinterpret_cast< wxImage * >(argp1);
17825 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17826 if (!SWIG_IsOK(res2)) {
17827 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17828 }
17829 if (!argp2) {
17830 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17831 }
17832 arg2 = reinterpret_cast< wxImage * >(argp2);
17833 if (obj2) {
17834 ecode3 = SWIG_AsVal_int(obj2, &val3);
17835 if (!SWIG_IsOK(ecode3)) {
17836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17837 }
17838 arg3 = static_cast< int >(val3);
17839 }
17840 if (obj3) {
17841 ecode4 = SWIG_AsVal_int(obj3, &val4);
17842 if (!SWIG_IsOK(ecode4)) {
17843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17844 }
17845 arg4 = static_cast< int >(val4);
17846 }
17847 {
17848 PyThreadState* __tstate = wxPyBeginAllowThreads();
17849 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17850 wxPyEndAllowThreads(__tstate);
17851 if (PyErr_Occurred()) SWIG_fail;
17852 }
17853 {
17854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17855 }
17856 return resultobj;
17857 fail:
17858 return NULL;
17859 }
17860
17861
17862 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17863 PyObject *obj;
17864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17865 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17866 return SWIG_Py_Void();
17867 }
17868
17869 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17870 PyObject *resultobj = 0;
17871 wxEvtHandler *result = 0 ;
17872
17873 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17874 {
17875 PyThreadState* __tstate = wxPyBeginAllowThreads();
17876 result = (wxEvtHandler *)new wxEvtHandler();
17877 wxPyEndAllowThreads(__tstate);
17878 if (PyErr_Occurred()) SWIG_fail;
17879 }
17880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17881 return resultobj;
17882 fail:
17883 return NULL;
17884 }
17885
17886
17887 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17888 PyObject *resultobj = 0;
17889 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17890 wxEvtHandler *result = 0 ;
17891 void *argp1 = 0 ;
17892 int res1 = 0 ;
17893 PyObject *swig_obj[1] ;
17894
17895 if (!args) SWIG_fail;
17896 swig_obj[0] = args;
17897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17898 if (!SWIG_IsOK(res1)) {
17899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17900 }
17901 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17902 {
17903 PyThreadState* __tstate = wxPyBeginAllowThreads();
17904 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17905 wxPyEndAllowThreads(__tstate);
17906 if (PyErr_Occurred()) SWIG_fail;
17907 }
17908 {
17909 resultobj = wxPyMake_wxObject(result, 0);
17910 }
17911 return resultobj;
17912 fail:
17913 return NULL;
17914 }
17915
17916
17917 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17918 PyObject *resultobj = 0;
17919 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17920 wxEvtHandler *result = 0 ;
17921 void *argp1 = 0 ;
17922 int res1 = 0 ;
17923 PyObject *swig_obj[1] ;
17924
17925 if (!args) SWIG_fail;
17926 swig_obj[0] = args;
17927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17928 if (!SWIG_IsOK(res1)) {
17929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17930 }
17931 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17932 {
17933 PyThreadState* __tstate = wxPyBeginAllowThreads();
17934 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 {
17939 resultobj = wxPyMake_wxObject(result, 0);
17940 }
17941 return resultobj;
17942 fail:
17943 return NULL;
17944 }
17945
17946
17947 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17948 PyObject *resultobj = 0;
17949 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17950 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17951 void *argp1 = 0 ;
17952 int res1 = 0 ;
17953 void *argp2 = 0 ;
17954 int res2 = 0 ;
17955 PyObject * obj0 = 0 ;
17956 PyObject * obj1 = 0 ;
17957 char * kwnames[] = {
17958 (char *) "self",(char *) "handler", NULL
17959 };
17960
17961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17963 if (!SWIG_IsOK(res1)) {
17964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17965 }
17966 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17967 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17968 if (!SWIG_IsOK(res2)) {
17969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17970 }
17971 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17972 {
17973 PyThreadState* __tstate = wxPyBeginAllowThreads();
17974 (arg1)->SetNextHandler(arg2);
17975 wxPyEndAllowThreads(__tstate);
17976 if (PyErr_Occurred()) SWIG_fail;
17977 }
17978 resultobj = SWIG_Py_Void();
17979 return resultobj;
17980 fail:
17981 return NULL;
17982 }
17983
17984
17985 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17986 PyObject *resultobj = 0;
17987 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17988 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17989 void *argp1 = 0 ;
17990 int res1 = 0 ;
17991 void *argp2 = 0 ;
17992 int res2 = 0 ;
17993 PyObject * obj0 = 0 ;
17994 PyObject * obj1 = 0 ;
17995 char * kwnames[] = {
17996 (char *) "self",(char *) "handler", NULL
17997 };
17998
17999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18001 if (!SWIG_IsOK(res1)) {
18002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18003 }
18004 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18005 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18006 if (!SWIG_IsOK(res2)) {
18007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18008 }
18009 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18010 {
18011 PyThreadState* __tstate = wxPyBeginAllowThreads();
18012 (arg1)->SetPreviousHandler(arg2);
18013 wxPyEndAllowThreads(__tstate);
18014 if (PyErr_Occurred()) SWIG_fail;
18015 }
18016 resultobj = SWIG_Py_Void();
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18024 PyObject *resultobj = 0;
18025 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18026 bool result;
18027 void *argp1 = 0 ;
18028 int res1 = 0 ;
18029 PyObject *swig_obj[1] ;
18030
18031 if (!args) SWIG_fail;
18032 swig_obj[0] = args;
18033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18034 if (!SWIG_IsOK(res1)) {
18035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18036 }
18037 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18038 {
18039 PyThreadState* __tstate = wxPyBeginAllowThreads();
18040 result = (bool)(arg1)->GetEvtHandlerEnabled();
18041 wxPyEndAllowThreads(__tstate);
18042 if (PyErr_Occurred()) SWIG_fail;
18043 }
18044 {
18045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18046 }
18047 return resultobj;
18048 fail:
18049 return NULL;
18050 }
18051
18052
18053 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18054 PyObject *resultobj = 0;
18055 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18056 bool arg2 ;
18057 void *argp1 = 0 ;
18058 int res1 = 0 ;
18059 bool val2 ;
18060 int ecode2 = 0 ;
18061 PyObject * obj0 = 0 ;
18062 PyObject * obj1 = 0 ;
18063 char * kwnames[] = {
18064 (char *) "self",(char *) "enabled", NULL
18065 };
18066
18067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18069 if (!SWIG_IsOK(res1)) {
18070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18071 }
18072 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18073 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18074 if (!SWIG_IsOK(ecode2)) {
18075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18076 }
18077 arg2 = static_cast< bool >(val2);
18078 {
18079 PyThreadState* __tstate = wxPyBeginAllowThreads();
18080 (arg1)->SetEvtHandlerEnabled(arg2);
18081 wxPyEndAllowThreads(__tstate);
18082 if (PyErr_Occurred()) SWIG_fail;
18083 }
18084 resultobj = SWIG_Py_Void();
18085 return resultobj;
18086 fail:
18087 return NULL;
18088 }
18089
18090
18091 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18092 PyObject *resultobj = 0;
18093 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18094 wxEvent *arg2 = 0 ;
18095 bool result;
18096 void *argp1 = 0 ;
18097 int res1 = 0 ;
18098 void *argp2 = 0 ;
18099 int res2 = 0 ;
18100 PyObject * obj0 = 0 ;
18101 PyObject * obj1 = 0 ;
18102 char * kwnames[] = {
18103 (char *) "self",(char *) "event", NULL
18104 };
18105
18106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18108 if (!SWIG_IsOK(res1)) {
18109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18110 }
18111 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18112 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18113 if (!SWIG_IsOK(res2)) {
18114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18115 }
18116 if (!argp2) {
18117 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18118 }
18119 arg2 = reinterpret_cast< wxEvent * >(argp2);
18120 {
18121 PyThreadState* __tstate = wxPyBeginAllowThreads();
18122 result = (bool)(arg1)->ProcessEvent(*arg2);
18123 wxPyEndAllowThreads(__tstate);
18124 if (PyErr_Occurred()) SWIG_fail;
18125 }
18126 {
18127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18128 }
18129 return resultobj;
18130 fail:
18131 return NULL;
18132 }
18133
18134
18135 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18136 PyObject *resultobj = 0;
18137 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18138 wxEvent *arg2 = 0 ;
18139 void *argp1 = 0 ;
18140 int res1 = 0 ;
18141 void *argp2 = 0 ;
18142 int res2 = 0 ;
18143 PyObject * obj0 = 0 ;
18144 PyObject * obj1 = 0 ;
18145 char * kwnames[] = {
18146 (char *) "self",(char *) "event", NULL
18147 };
18148
18149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18151 if (!SWIG_IsOK(res1)) {
18152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18153 }
18154 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18155 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18156 if (!SWIG_IsOK(res2)) {
18157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18158 }
18159 if (!argp2) {
18160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18161 }
18162 arg2 = reinterpret_cast< wxEvent * >(argp2);
18163 {
18164 PyThreadState* __tstate = wxPyBeginAllowThreads();
18165 (arg1)->AddPendingEvent(*arg2);
18166 wxPyEndAllowThreads(__tstate);
18167 if (PyErr_Occurred()) SWIG_fail;
18168 }
18169 resultobj = SWIG_Py_Void();
18170 return resultobj;
18171 fail:
18172 return NULL;
18173 }
18174
18175
18176 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18177 PyObject *resultobj = 0;
18178 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18179 void *argp1 = 0 ;
18180 int res1 = 0 ;
18181 PyObject *swig_obj[1] ;
18182
18183 if (!args) SWIG_fail;
18184 swig_obj[0] = args;
18185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18186 if (!SWIG_IsOK(res1)) {
18187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18188 }
18189 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18190 {
18191 PyThreadState* __tstate = wxPyBeginAllowThreads();
18192 (arg1)->ProcessPendingEvents();
18193 wxPyEndAllowThreads(__tstate);
18194 if (PyErr_Occurred()) SWIG_fail;
18195 }
18196 resultobj = SWIG_Py_Void();
18197 return resultobj;
18198 fail:
18199 return NULL;
18200 }
18201
18202
18203 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18204 PyObject *resultobj = 0;
18205 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18206 int arg2 ;
18207 int arg3 ;
18208 int arg4 ;
18209 PyObject *arg5 = (PyObject *) 0 ;
18210 void *argp1 = 0 ;
18211 int res1 = 0 ;
18212 int val2 ;
18213 int ecode2 = 0 ;
18214 int val3 ;
18215 int ecode3 = 0 ;
18216 int val4 ;
18217 int ecode4 = 0 ;
18218 PyObject * obj0 = 0 ;
18219 PyObject * obj1 = 0 ;
18220 PyObject * obj2 = 0 ;
18221 PyObject * obj3 = 0 ;
18222 PyObject * obj4 = 0 ;
18223 char * kwnames[] = {
18224 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18225 };
18226
18227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18229 if (!SWIG_IsOK(res1)) {
18230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18231 }
18232 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18233 ecode2 = SWIG_AsVal_int(obj1, &val2);
18234 if (!SWIG_IsOK(ecode2)) {
18235 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18236 }
18237 arg2 = static_cast< int >(val2);
18238 ecode3 = SWIG_AsVal_int(obj2, &val3);
18239 if (!SWIG_IsOK(ecode3)) {
18240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18241 }
18242 arg3 = static_cast< int >(val3);
18243 ecode4 = SWIG_AsVal_int(obj3, &val4);
18244 if (!SWIG_IsOK(ecode4)) {
18245 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18246 }
18247 arg4 = static_cast< int >(val4);
18248 arg5 = obj4;
18249 {
18250 PyThreadState* __tstate = wxPyBeginAllowThreads();
18251 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18252 wxPyEndAllowThreads(__tstate);
18253 if (PyErr_Occurred()) SWIG_fail;
18254 }
18255 resultobj = SWIG_Py_Void();
18256 return resultobj;
18257 fail:
18258 return NULL;
18259 }
18260
18261
18262 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18263 PyObject *resultobj = 0;
18264 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18265 int arg2 ;
18266 int arg3 = (int) -1 ;
18267 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18268 bool result;
18269 void *argp1 = 0 ;
18270 int res1 = 0 ;
18271 int val2 ;
18272 int ecode2 = 0 ;
18273 int val3 ;
18274 int ecode3 = 0 ;
18275 int val4 ;
18276 int ecode4 = 0 ;
18277 PyObject * obj0 = 0 ;
18278 PyObject * obj1 = 0 ;
18279 PyObject * obj2 = 0 ;
18280 PyObject * obj3 = 0 ;
18281 char * kwnames[] = {
18282 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18283 };
18284
18285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18287 if (!SWIG_IsOK(res1)) {
18288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18289 }
18290 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18291 ecode2 = SWIG_AsVal_int(obj1, &val2);
18292 if (!SWIG_IsOK(ecode2)) {
18293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18294 }
18295 arg2 = static_cast< int >(val2);
18296 if (obj2) {
18297 ecode3 = SWIG_AsVal_int(obj2, &val3);
18298 if (!SWIG_IsOK(ecode3)) {
18299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18300 }
18301 arg3 = static_cast< int >(val3);
18302 }
18303 if (obj3) {
18304 ecode4 = SWIG_AsVal_int(obj3, &val4);
18305 if (!SWIG_IsOK(ecode4)) {
18306 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18307 }
18308 arg4 = static_cast< wxEventType >(val4);
18309 }
18310 {
18311 PyThreadState* __tstate = wxPyBeginAllowThreads();
18312 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18313 wxPyEndAllowThreads(__tstate);
18314 if (PyErr_Occurred()) SWIG_fail;
18315 }
18316 {
18317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18318 }
18319 return resultobj;
18320 fail:
18321 return NULL;
18322 }
18323
18324
18325 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18326 PyObject *resultobj = 0;
18327 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18328 PyObject *arg2 = (PyObject *) 0 ;
18329 bool arg3 = (bool) true ;
18330 void *argp1 = 0 ;
18331 int res1 = 0 ;
18332 bool val3 ;
18333 int ecode3 = 0 ;
18334 PyObject * obj0 = 0 ;
18335 PyObject * obj1 = 0 ;
18336 PyObject * obj2 = 0 ;
18337 char * kwnames[] = {
18338 (char *) "self",(char *) "_self",(char *) "incref", NULL
18339 };
18340
18341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18343 if (!SWIG_IsOK(res1)) {
18344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18345 }
18346 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18347 arg2 = obj1;
18348 if (obj2) {
18349 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18350 if (!SWIG_IsOK(ecode3)) {
18351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18352 }
18353 arg3 = static_cast< bool >(val3);
18354 }
18355 {
18356 PyThreadState* __tstate = wxPyBeginAllowThreads();
18357 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18358 wxPyEndAllowThreads(__tstate);
18359 if (PyErr_Occurred()) SWIG_fail;
18360 }
18361 resultobj = SWIG_Py_Void();
18362 return resultobj;
18363 fail:
18364 return NULL;
18365 }
18366
18367
18368 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18369 PyObject *obj;
18370 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18371 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18372 return SWIG_Py_Void();
18373 }
18374
18375 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18376 return SWIG_Python_InitShadowInstance(args);
18377 }
18378
18379 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18380 PyObject *resultobj = 0;
18381 wxEventType result;
18382
18383 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18384 {
18385 PyThreadState* __tstate = wxPyBeginAllowThreads();
18386 result = (wxEventType)wxNewEventType();
18387 wxPyEndAllowThreads(__tstate);
18388 if (PyErr_Occurred()) SWIG_fail;
18389 }
18390 resultobj = SWIG_From_int(static_cast< int >(result));
18391 return resultobj;
18392 fail:
18393 return NULL;
18394 }
18395
18396
18397 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18398 PyObject *resultobj = 0;
18399 wxEvent *arg1 = (wxEvent *) 0 ;
18400 void *argp1 = 0 ;
18401 int res1 = 0 ;
18402 PyObject *swig_obj[1] ;
18403
18404 if (!args) SWIG_fail;
18405 swig_obj[0] = args;
18406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18407 if (!SWIG_IsOK(res1)) {
18408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18409 }
18410 arg1 = reinterpret_cast< wxEvent * >(argp1);
18411 {
18412 PyThreadState* __tstate = wxPyBeginAllowThreads();
18413 delete arg1;
18414
18415 wxPyEndAllowThreads(__tstate);
18416 if (PyErr_Occurred()) SWIG_fail;
18417 }
18418 resultobj = SWIG_Py_Void();
18419 return resultobj;
18420 fail:
18421 return NULL;
18422 }
18423
18424
18425 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18426 PyObject *resultobj = 0;
18427 wxEvent *arg1 = (wxEvent *) 0 ;
18428 wxEventType arg2 ;
18429 void *argp1 = 0 ;
18430 int res1 = 0 ;
18431 int val2 ;
18432 int ecode2 = 0 ;
18433 PyObject * obj0 = 0 ;
18434 PyObject * obj1 = 0 ;
18435 char * kwnames[] = {
18436 (char *) "self",(char *) "typ", NULL
18437 };
18438
18439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18441 if (!SWIG_IsOK(res1)) {
18442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18443 }
18444 arg1 = reinterpret_cast< wxEvent * >(argp1);
18445 ecode2 = SWIG_AsVal_int(obj1, &val2);
18446 if (!SWIG_IsOK(ecode2)) {
18447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18448 }
18449 arg2 = static_cast< wxEventType >(val2);
18450 {
18451 PyThreadState* __tstate = wxPyBeginAllowThreads();
18452 (arg1)->SetEventType(arg2);
18453 wxPyEndAllowThreads(__tstate);
18454 if (PyErr_Occurred()) SWIG_fail;
18455 }
18456 resultobj = SWIG_Py_Void();
18457 return resultobj;
18458 fail:
18459 return NULL;
18460 }
18461
18462
18463 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18464 PyObject *resultobj = 0;
18465 wxEvent *arg1 = (wxEvent *) 0 ;
18466 wxEventType result;
18467 void *argp1 = 0 ;
18468 int res1 = 0 ;
18469 PyObject *swig_obj[1] ;
18470
18471 if (!args) SWIG_fail;
18472 swig_obj[0] = args;
18473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18474 if (!SWIG_IsOK(res1)) {
18475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18476 }
18477 arg1 = reinterpret_cast< wxEvent * >(argp1);
18478 {
18479 PyThreadState* __tstate = wxPyBeginAllowThreads();
18480 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18481 wxPyEndAllowThreads(__tstate);
18482 if (PyErr_Occurred()) SWIG_fail;
18483 }
18484 resultobj = SWIG_From_int(static_cast< int >(result));
18485 return resultobj;
18486 fail:
18487 return NULL;
18488 }
18489
18490
18491 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18492 PyObject *resultobj = 0;
18493 wxEvent *arg1 = (wxEvent *) 0 ;
18494 wxObject *result = 0 ;
18495 void *argp1 = 0 ;
18496 int res1 = 0 ;
18497 PyObject *swig_obj[1] ;
18498
18499 if (!args) SWIG_fail;
18500 swig_obj[0] = args;
18501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18502 if (!SWIG_IsOK(res1)) {
18503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18504 }
18505 arg1 = reinterpret_cast< wxEvent * >(argp1);
18506 {
18507 PyThreadState* __tstate = wxPyBeginAllowThreads();
18508 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18509 wxPyEndAllowThreads(__tstate);
18510 if (PyErr_Occurred()) SWIG_fail;
18511 }
18512 {
18513 resultobj = wxPyMake_wxObject(result, (bool)0);
18514 }
18515 return resultobj;
18516 fail:
18517 return NULL;
18518 }
18519
18520
18521 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18522 PyObject *resultobj = 0;
18523 wxEvent *arg1 = (wxEvent *) 0 ;
18524 wxObject *arg2 = (wxObject *) 0 ;
18525 void *argp1 = 0 ;
18526 int res1 = 0 ;
18527 void *argp2 = 0 ;
18528 int res2 = 0 ;
18529 PyObject * obj0 = 0 ;
18530 PyObject * obj1 = 0 ;
18531 char * kwnames[] = {
18532 (char *) "self",(char *) "obj", NULL
18533 };
18534
18535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18537 if (!SWIG_IsOK(res1)) {
18538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18539 }
18540 arg1 = reinterpret_cast< wxEvent * >(argp1);
18541 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18542 if (!SWIG_IsOK(res2)) {
18543 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18544 }
18545 arg2 = reinterpret_cast< wxObject * >(argp2);
18546 {
18547 PyThreadState* __tstate = wxPyBeginAllowThreads();
18548 (arg1)->SetEventObject(arg2);
18549 wxPyEndAllowThreads(__tstate);
18550 if (PyErr_Occurred()) SWIG_fail;
18551 }
18552 resultobj = SWIG_Py_Void();
18553 return resultobj;
18554 fail:
18555 return NULL;
18556 }
18557
18558
18559 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18560 PyObject *resultobj = 0;
18561 wxEvent *arg1 = (wxEvent *) 0 ;
18562 long result;
18563 void *argp1 = 0 ;
18564 int res1 = 0 ;
18565 PyObject *swig_obj[1] ;
18566
18567 if (!args) SWIG_fail;
18568 swig_obj[0] = args;
18569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18570 if (!SWIG_IsOK(res1)) {
18571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18572 }
18573 arg1 = reinterpret_cast< wxEvent * >(argp1);
18574 {
18575 PyThreadState* __tstate = wxPyBeginAllowThreads();
18576 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18577 wxPyEndAllowThreads(__tstate);
18578 if (PyErr_Occurred()) SWIG_fail;
18579 }
18580 resultobj = SWIG_From_long(static_cast< long >(result));
18581 return resultobj;
18582 fail:
18583 return NULL;
18584 }
18585
18586
18587 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18588 PyObject *resultobj = 0;
18589 wxEvent *arg1 = (wxEvent *) 0 ;
18590 long arg2 = (long) 0 ;
18591 void *argp1 = 0 ;
18592 int res1 = 0 ;
18593 long val2 ;
18594 int ecode2 = 0 ;
18595 PyObject * obj0 = 0 ;
18596 PyObject * obj1 = 0 ;
18597 char * kwnames[] = {
18598 (char *) "self",(char *) "ts", NULL
18599 };
18600
18601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18603 if (!SWIG_IsOK(res1)) {
18604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18605 }
18606 arg1 = reinterpret_cast< wxEvent * >(argp1);
18607 if (obj1) {
18608 ecode2 = SWIG_AsVal_long(obj1, &val2);
18609 if (!SWIG_IsOK(ecode2)) {
18610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18611 }
18612 arg2 = static_cast< long >(val2);
18613 }
18614 {
18615 PyThreadState* __tstate = wxPyBeginAllowThreads();
18616 (arg1)->SetTimestamp(arg2);
18617 wxPyEndAllowThreads(__tstate);
18618 if (PyErr_Occurred()) SWIG_fail;
18619 }
18620 resultobj = SWIG_Py_Void();
18621 return resultobj;
18622 fail:
18623 return NULL;
18624 }
18625
18626
18627 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18628 PyObject *resultobj = 0;
18629 wxEvent *arg1 = (wxEvent *) 0 ;
18630 int result;
18631 void *argp1 = 0 ;
18632 int res1 = 0 ;
18633 PyObject *swig_obj[1] ;
18634
18635 if (!args) SWIG_fail;
18636 swig_obj[0] = args;
18637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18638 if (!SWIG_IsOK(res1)) {
18639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18640 }
18641 arg1 = reinterpret_cast< wxEvent * >(argp1);
18642 {
18643 PyThreadState* __tstate = wxPyBeginAllowThreads();
18644 result = (int)((wxEvent const *)arg1)->GetId();
18645 wxPyEndAllowThreads(__tstate);
18646 if (PyErr_Occurred()) SWIG_fail;
18647 }
18648 resultobj = SWIG_From_int(static_cast< int >(result));
18649 return resultobj;
18650 fail:
18651 return NULL;
18652 }
18653
18654
18655 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18656 PyObject *resultobj = 0;
18657 wxEvent *arg1 = (wxEvent *) 0 ;
18658 int arg2 ;
18659 void *argp1 = 0 ;
18660 int res1 = 0 ;
18661 int val2 ;
18662 int ecode2 = 0 ;
18663 PyObject * obj0 = 0 ;
18664 PyObject * obj1 = 0 ;
18665 char * kwnames[] = {
18666 (char *) "self",(char *) "Id", NULL
18667 };
18668
18669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18671 if (!SWIG_IsOK(res1)) {
18672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18673 }
18674 arg1 = reinterpret_cast< wxEvent * >(argp1);
18675 ecode2 = SWIG_AsVal_int(obj1, &val2);
18676 if (!SWIG_IsOK(ecode2)) {
18677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18678 }
18679 arg2 = static_cast< int >(val2);
18680 {
18681 PyThreadState* __tstate = wxPyBeginAllowThreads();
18682 (arg1)->SetId(arg2);
18683 wxPyEndAllowThreads(__tstate);
18684 if (PyErr_Occurred()) SWIG_fail;
18685 }
18686 resultobj = SWIG_Py_Void();
18687 return resultobj;
18688 fail:
18689 return NULL;
18690 }
18691
18692
18693 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18694 PyObject *resultobj = 0;
18695 wxEvent *arg1 = (wxEvent *) 0 ;
18696 bool result;
18697 void *argp1 = 0 ;
18698 int res1 = 0 ;
18699 PyObject *swig_obj[1] ;
18700
18701 if (!args) SWIG_fail;
18702 swig_obj[0] = args;
18703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18704 if (!SWIG_IsOK(res1)) {
18705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18706 }
18707 arg1 = reinterpret_cast< wxEvent * >(argp1);
18708 {
18709 PyThreadState* __tstate = wxPyBeginAllowThreads();
18710 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18711 wxPyEndAllowThreads(__tstate);
18712 if (PyErr_Occurred()) SWIG_fail;
18713 }
18714 {
18715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18716 }
18717 return resultobj;
18718 fail:
18719 return NULL;
18720 }
18721
18722
18723 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18724 PyObject *resultobj = 0;
18725 wxEvent *arg1 = (wxEvent *) 0 ;
18726 bool arg2 = (bool) true ;
18727 void *argp1 = 0 ;
18728 int res1 = 0 ;
18729 bool val2 ;
18730 int ecode2 = 0 ;
18731 PyObject * obj0 = 0 ;
18732 PyObject * obj1 = 0 ;
18733 char * kwnames[] = {
18734 (char *) "self",(char *) "skip", NULL
18735 };
18736
18737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18739 if (!SWIG_IsOK(res1)) {
18740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18741 }
18742 arg1 = reinterpret_cast< wxEvent * >(argp1);
18743 if (obj1) {
18744 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18745 if (!SWIG_IsOK(ecode2)) {
18746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18747 }
18748 arg2 = static_cast< bool >(val2);
18749 }
18750 {
18751 PyThreadState* __tstate = wxPyBeginAllowThreads();
18752 (arg1)->Skip(arg2);
18753 wxPyEndAllowThreads(__tstate);
18754 if (PyErr_Occurred()) SWIG_fail;
18755 }
18756 resultobj = SWIG_Py_Void();
18757 return resultobj;
18758 fail:
18759 return NULL;
18760 }
18761
18762
18763 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18764 PyObject *resultobj = 0;
18765 wxEvent *arg1 = (wxEvent *) 0 ;
18766 bool result;
18767 void *argp1 = 0 ;
18768 int res1 = 0 ;
18769 PyObject *swig_obj[1] ;
18770
18771 if (!args) SWIG_fail;
18772 swig_obj[0] = args;
18773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18774 if (!SWIG_IsOK(res1)) {
18775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18776 }
18777 arg1 = reinterpret_cast< wxEvent * >(argp1);
18778 {
18779 PyThreadState* __tstate = wxPyBeginAllowThreads();
18780 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18781 wxPyEndAllowThreads(__tstate);
18782 if (PyErr_Occurred()) SWIG_fail;
18783 }
18784 {
18785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18786 }
18787 return resultobj;
18788 fail:
18789 return NULL;
18790 }
18791
18792
18793 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18794 PyObject *resultobj = 0;
18795 wxEvent *arg1 = (wxEvent *) 0 ;
18796 bool result;
18797 void *argp1 = 0 ;
18798 int res1 = 0 ;
18799 PyObject *swig_obj[1] ;
18800
18801 if (!args) SWIG_fail;
18802 swig_obj[0] = args;
18803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18804 if (!SWIG_IsOK(res1)) {
18805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18806 }
18807 arg1 = reinterpret_cast< wxEvent * >(argp1);
18808 {
18809 PyThreadState* __tstate = wxPyBeginAllowThreads();
18810 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18811 wxPyEndAllowThreads(__tstate);
18812 if (PyErr_Occurred()) SWIG_fail;
18813 }
18814 {
18815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18816 }
18817 return resultobj;
18818 fail:
18819 return NULL;
18820 }
18821
18822
18823 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18824 PyObject *resultobj = 0;
18825 wxEvent *arg1 = (wxEvent *) 0 ;
18826 int result;
18827 void *argp1 = 0 ;
18828 int res1 = 0 ;
18829 PyObject *swig_obj[1] ;
18830
18831 if (!args) SWIG_fail;
18832 swig_obj[0] = args;
18833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18834 if (!SWIG_IsOK(res1)) {
18835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18836 }
18837 arg1 = reinterpret_cast< wxEvent * >(argp1);
18838 {
18839 PyThreadState* __tstate = wxPyBeginAllowThreads();
18840 result = (int)(arg1)->StopPropagation();
18841 wxPyEndAllowThreads(__tstate);
18842 if (PyErr_Occurred()) SWIG_fail;
18843 }
18844 resultobj = SWIG_From_int(static_cast< int >(result));
18845 return resultobj;
18846 fail:
18847 return NULL;
18848 }
18849
18850
18851 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18852 PyObject *resultobj = 0;
18853 wxEvent *arg1 = (wxEvent *) 0 ;
18854 int arg2 ;
18855 void *argp1 = 0 ;
18856 int res1 = 0 ;
18857 int val2 ;
18858 int ecode2 = 0 ;
18859 PyObject * obj0 = 0 ;
18860 PyObject * obj1 = 0 ;
18861 char * kwnames[] = {
18862 (char *) "self",(char *) "propagationLevel", NULL
18863 };
18864
18865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18867 if (!SWIG_IsOK(res1)) {
18868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18869 }
18870 arg1 = reinterpret_cast< wxEvent * >(argp1);
18871 ecode2 = SWIG_AsVal_int(obj1, &val2);
18872 if (!SWIG_IsOK(ecode2)) {
18873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18874 }
18875 arg2 = static_cast< int >(val2);
18876 {
18877 PyThreadState* __tstate = wxPyBeginAllowThreads();
18878 (arg1)->ResumePropagation(arg2);
18879 wxPyEndAllowThreads(__tstate);
18880 if (PyErr_Occurred()) SWIG_fail;
18881 }
18882 resultobj = SWIG_Py_Void();
18883 return resultobj;
18884 fail:
18885 return NULL;
18886 }
18887
18888
18889 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18890 PyObject *resultobj = 0;
18891 wxEvent *arg1 = (wxEvent *) 0 ;
18892 wxEvent *result = 0 ;
18893 void *argp1 = 0 ;
18894 int res1 = 0 ;
18895 PyObject *swig_obj[1] ;
18896
18897 if (!args) SWIG_fail;
18898 swig_obj[0] = args;
18899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18900 if (!SWIG_IsOK(res1)) {
18901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18902 }
18903 arg1 = reinterpret_cast< wxEvent * >(argp1);
18904 {
18905 PyThreadState* __tstate = wxPyBeginAllowThreads();
18906 result = (wxEvent *)(arg1)->Clone();
18907 wxPyEndAllowThreads(__tstate);
18908 if (PyErr_Occurred()) SWIG_fail;
18909 }
18910 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18911 return resultobj;
18912 fail:
18913 return NULL;
18914 }
18915
18916
18917 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18918 PyObject *obj;
18919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18920 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18921 return SWIG_Py_Void();
18922 }
18923
18924 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18925 PyObject *resultobj = 0;
18926 wxEvent *arg1 = 0 ;
18927 wxPropagationDisabler *result = 0 ;
18928 void *argp1 = 0 ;
18929 int res1 = 0 ;
18930 PyObject * obj0 = 0 ;
18931 char * kwnames[] = {
18932 (char *) "event", NULL
18933 };
18934
18935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18936 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18937 if (!SWIG_IsOK(res1)) {
18938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18939 }
18940 if (!argp1) {
18941 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18942 }
18943 arg1 = reinterpret_cast< wxEvent * >(argp1);
18944 {
18945 PyThreadState* __tstate = wxPyBeginAllowThreads();
18946 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18947 wxPyEndAllowThreads(__tstate);
18948 if (PyErr_Occurred()) SWIG_fail;
18949 }
18950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18951 return resultobj;
18952 fail:
18953 return NULL;
18954 }
18955
18956
18957 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18958 PyObject *resultobj = 0;
18959 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18960 void *argp1 = 0 ;
18961 int res1 = 0 ;
18962 PyObject *swig_obj[1] ;
18963
18964 if (!args) SWIG_fail;
18965 swig_obj[0] = args;
18966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18967 if (!SWIG_IsOK(res1)) {
18968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18969 }
18970 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18971 {
18972 PyThreadState* __tstate = wxPyBeginAllowThreads();
18973 delete arg1;
18974
18975 wxPyEndAllowThreads(__tstate);
18976 if (PyErr_Occurred()) SWIG_fail;
18977 }
18978 resultobj = SWIG_Py_Void();
18979 return resultobj;
18980 fail:
18981 return NULL;
18982 }
18983
18984
18985 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18986 PyObject *obj;
18987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18989 return SWIG_Py_Void();
18990 }
18991
18992 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18993 return SWIG_Python_InitShadowInstance(args);
18994 }
18995
18996 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18997 PyObject *resultobj = 0;
18998 wxEvent *arg1 = 0 ;
18999 wxPropagateOnce *result = 0 ;
19000 void *argp1 = 0 ;
19001 int res1 = 0 ;
19002 PyObject * obj0 = 0 ;
19003 char * kwnames[] = {
19004 (char *) "event", NULL
19005 };
19006
19007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19008 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19009 if (!SWIG_IsOK(res1)) {
19010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19011 }
19012 if (!argp1) {
19013 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19014 }
19015 arg1 = reinterpret_cast< wxEvent * >(argp1);
19016 {
19017 PyThreadState* __tstate = wxPyBeginAllowThreads();
19018 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19019 wxPyEndAllowThreads(__tstate);
19020 if (PyErr_Occurred()) SWIG_fail;
19021 }
19022 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19023 return resultobj;
19024 fail:
19025 return NULL;
19026 }
19027
19028
19029 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19030 PyObject *resultobj = 0;
19031 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19032 void *argp1 = 0 ;
19033 int res1 = 0 ;
19034 PyObject *swig_obj[1] ;
19035
19036 if (!args) SWIG_fail;
19037 swig_obj[0] = args;
19038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19039 if (!SWIG_IsOK(res1)) {
19040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19041 }
19042 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19043 {
19044 PyThreadState* __tstate = wxPyBeginAllowThreads();
19045 delete arg1;
19046
19047 wxPyEndAllowThreads(__tstate);
19048 if (PyErr_Occurred()) SWIG_fail;
19049 }
19050 resultobj = SWIG_Py_Void();
19051 return resultobj;
19052 fail:
19053 return NULL;
19054 }
19055
19056
19057 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19058 PyObject *obj;
19059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19060 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19061 return SWIG_Py_Void();
19062 }
19063
19064 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19065 return SWIG_Python_InitShadowInstance(args);
19066 }
19067
19068 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19069 PyObject *resultobj = 0;
19070 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19071 int arg2 = (int) 0 ;
19072 wxCommandEvent *result = 0 ;
19073 int val1 ;
19074 int ecode1 = 0 ;
19075 int val2 ;
19076 int ecode2 = 0 ;
19077 PyObject * obj0 = 0 ;
19078 PyObject * obj1 = 0 ;
19079 char * kwnames[] = {
19080 (char *) "commandType",(char *) "winid", NULL
19081 };
19082
19083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19084 if (obj0) {
19085 ecode1 = SWIG_AsVal_int(obj0, &val1);
19086 if (!SWIG_IsOK(ecode1)) {
19087 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19088 }
19089 arg1 = static_cast< wxEventType >(val1);
19090 }
19091 if (obj1) {
19092 ecode2 = SWIG_AsVal_int(obj1, &val2);
19093 if (!SWIG_IsOK(ecode2)) {
19094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19095 }
19096 arg2 = static_cast< int >(val2);
19097 }
19098 {
19099 PyThreadState* __tstate = wxPyBeginAllowThreads();
19100 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19101 wxPyEndAllowThreads(__tstate);
19102 if (PyErr_Occurred()) SWIG_fail;
19103 }
19104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19105 return resultobj;
19106 fail:
19107 return NULL;
19108 }
19109
19110
19111 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19112 PyObject *resultobj = 0;
19113 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19114 int result;
19115 void *argp1 = 0 ;
19116 int res1 = 0 ;
19117 PyObject *swig_obj[1] ;
19118
19119 if (!args) SWIG_fail;
19120 swig_obj[0] = args;
19121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19122 if (!SWIG_IsOK(res1)) {
19123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19124 }
19125 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19126 {
19127 PyThreadState* __tstate = wxPyBeginAllowThreads();
19128 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19129 wxPyEndAllowThreads(__tstate);
19130 if (PyErr_Occurred()) SWIG_fail;
19131 }
19132 resultobj = SWIG_From_int(static_cast< int >(result));
19133 return resultobj;
19134 fail:
19135 return NULL;
19136 }
19137
19138
19139 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19140 PyObject *resultobj = 0;
19141 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19142 wxString *arg2 = 0 ;
19143 void *argp1 = 0 ;
19144 int res1 = 0 ;
19145 bool temp2 = false ;
19146 PyObject * obj0 = 0 ;
19147 PyObject * obj1 = 0 ;
19148 char * kwnames[] = {
19149 (char *) "self",(char *) "s", NULL
19150 };
19151
19152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19154 if (!SWIG_IsOK(res1)) {
19155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19156 }
19157 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19158 {
19159 arg2 = wxString_in_helper(obj1);
19160 if (arg2 == NULL) SWIG_fail;
19161 temp2 = true;
19162 }
19163 {
19164 PyThreadState* __tstate = wxPyBeginAllowThreads();
19165 (arg1)->SetString((wxString const &)*arg2);
19166 wxPyEndAllowThreads(__tstate);
19167 if (PyErr_Occurred()) SWIG_fail;
19168 }
19169 resultobj = SWIG_Py_Void();
19170 {
19171 if (temp2)
19172 delete arg2;
19173 }
19174 return resultobj;
19175 fail:
19176 {
19177 if (temp2)
19178 delete arg2;
19179 }
19180 return NULL;
19181 }
19182
19183
19184 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19185 PyObject *resultobj = 0;
19186 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19187 wxString result;
19188 void *argp1 = 0 ;
19189 int res1 = 0 ;
19190 PyObject *swig_obj[1] ;
19191
19192 if (!args) SWIG_fail;
19193 swig_obj[0] = args;
19194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19195 if (!SWIG_IsOK(res1)) {
19196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19197 }
19198 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19199 {
19200 PyThreadState* __tstate = wxPyBeginAllowThreads();
19201 result = ((wxCommandEvent const *)arg1)->GetString();
19202 wxPyEndAllowThreads(__tstate);
19203 if (PyErr_Occurred()) SWIG_fail;
19204 }
19205 {
19206 #if wxUSE_UNICODE
19207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19208 #else
19209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19210 #endif
19211 }
19212 return resultobj;
19213 fail:
19214 return NULL;
19215 }
19216
19217
19218 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19219 PyObject *resultobj = 0;
19220 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19221 bool result;
19222 void *argp1 = 0 ;
19223 int res1 = 0 ;
19224 PyObject *swig_obj[1] ;
19225
19226 if (!args) SWIG_fail;
19227 swig_obj[0] = args;
19228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19229 if (!SWIG_IsOK(res1)) {
19230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19231 }
19232 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19236 wxPyEndAllowThreads(__tstate);
19237 if (PyErr_Occurred()) SWIG_fail;
19238 }
19239 {
19240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19241 }
19242 return resultobj;
19243 fail:
19244 return NULL;
19245 }
19246
19247
19248 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19249 PyObject *resultobj = 0;
19250 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19251 bool result;
19252 void *argp1 = 0 ;
19253 int res1 = 0 ;
19254 PyObject *swig_obj[1] ;
19255
19256 if (!args) SWIG_fail;
19257 swig_obj[0] = args;
19258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19259 if (!SWIG_IsOK(res1)) {
19260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19261 }
19262 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19263 {
19264 PyThreadState* __tstate = wxPyBeginAllowThreads();
19265 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19266 wxPyEndAllowThreads(__tstate);
19267 if (PyErr_Occurred()) SWIG_fail;
19268 }
19269 {
19270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19271 }
19272 return resultobj;
19273 fail:
19274 return NULL;
19275 }
19276
19277
19278 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19279 PyObject *resultobj = 0;
19280 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19281 long arg2 ;
19282 void *argp1 = 0 ;
19283 int res1 = 0 ;
19284 long val2 ;
19285 int ecode2 = 0 ;
19286 PyObject * obj0 = 0 ;
19287 PyObject * obj1 = 0 ;
19288 char * kwnames[] = {
19289 (char *) "self",(char *) "extraLong", NULL
19290 };
19291
19292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19294 if (!SWIG_IsOK(res1)) {
19295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19296 }
19297 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19298 ecode2 = SWIG_AsVal_long(obj1, &val2);
19299 if (!SWIG_IsOK(ecode2)) {
19300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19301 }
19302 arg2 = static_cast< long >(val2);
19303 {
19304 PyThreadState* __tstate = wxPyBeginAllowThreads();
19305 (arg1)->SetExtraLong(arg2);
19306 wxPyEndAllowThreads(__tstate);
19307 if (PyErr_Occurred()) SWIG_fail;
19308 }
19309 resultobj = SWIG_Py_Void();
19310 return resultobj;
19311 fail:
19312 return NULL;
19313 }
19314
19315
19316 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19317 PyObject *resultobj = 0;
19318 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19319 long result;
19320 void *argp1 = 0 ;
19321 int res1 = 0 ;
19322 PyObject *swig_obj[1] ;
19323
19324 if (!args) SWIG_fail;
19325 swig_obj[0] = args;
19326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19327 if (!SWIG_IsOK(res1)) {
19328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19329 }
19330 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19331 {
19332 PyThreadState* __tstate = wxPyBeginAllowThreads();
19333 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19334 wxPyEndAllowThreads(__tstate);
19335 if (PyErr_Occurred()) SWIG_fail;
19336 }
19337 resultobj = SWIG_From_long(static_cast< long >(result));
19338 return resultobj;
19339 fail:
19340 return NULL;
19341 }
19342
19343
19344 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19345 PyObject *resultobj = 0;
19346 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19347 int arg2 ;
19348 void *argp1 = 0 ;
19349 int res1 = 0 ;
19350 int val2 ;
19351 int ecode2 = 0 ;
19352 PyObject * obj0 = 0 ;
19353 PyObject * obj1 = 0 ;
19354 char * kwnames[] = {
19355 (char *) "self",(char *) "i", NULL
19356 };
19357
19358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19360 if (!SWIG_IsOK(res1)) {
19361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19362 }
19363 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19364 ecode2 = SWIG_AsVal_int(obj1, &val2);
19365 if (!SWIG_IsOK(ecode2)) {
19366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19367 }
19368 arg2 = static_cast< int >(val2);
19369 {
19370 PyThreadState* __tstate = wxPyBeginAllowThreads();
19371 (arg1)->SetInt(arg2);
19372 wxPyEndAllowThreads(__tstate);
19373 if (PyErr_Occurred()) SWIG_fail;
19374 }
19375 resultobj = SWIG_Py_Void();
19376 return resultobj;
19377 fail:
19378 return NULL;
19379 }
19380
19381
19382 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19383 PyObject *resultobj = 0;
19384 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19385 int result;
19386 void *argp1 = 0 ;
19387 int res1 = 0 ;
19388 PyObject *swig_obj[1] ;
19389
19390 if (!args) SWIG_fail;
19391 swig_obj[0] = args;
19392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19393 if (!SWIG_IsOK(res1)) {
19394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19395 }
19396 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19397 {
19398 PyThreadState* __tstate = wxPyBeginAllowThreads();
19399 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19400 wxPyEndAllowThreads(__tstate);
19401 if (PyErr_Occurred()) SWIG_fail;
19402 }
19403 resultobj = SWIG_From_int(static_cast< int >(result));
19404 return resultobj;
19405 fail:
19406 return NULL;
19407 }
19408
19409
19410 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19411 PyObject *resultobj = 0;
19412 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19413 PyObject *result = 0 ;
19414 void *argp1 = 0 ;
19415 int res1 = 0 ;
19416 PyObject *swig_obj[1] ;
19417
19418 if (!args) SWIG_fail;
19419 swig_obj[0] = args;
19420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19421 if (!SWIG_IsOK(res1)) {
19422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19423 }
19424 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19425 {
19426 PyThreadState* __tstate = wxPyBeginAllowThreads();
19427 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19428 wxPyEndAllowThreads(__tstate);
19429 if (PyErr_Occurred()) SWIG_fail;
19430 }
19431 resultobj = result;
19432 return resultobj;
19433 fail:
19434 return NULL;
19435 }
19436
19437
19438 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19439 PyObject *resultobj = 0;
19440 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19441 PyObject *arg2 = (PyObject *) 0 ;
19442 void *argp1 = 0 ;
19443 int res1 = 0 ;
19444 PyObject * obj0 = 0 ;
19445 PyObject * obj1 = 0 ;
19446 char * kwnames[] = {
19447 (char *) "self",(char *) "clientData", NULL
19448 };
19449
19450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19452 if (!SWIG_IsOK(res1)) {
19453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19454 }
19455 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19456 arg2 = obj1;
19457 {
19458 PyThreadState* __tstate = wxPyBeginAllowThreads();
19459 wxCommandEvent_SetClientData(arg1,arg2);
19460 wxPyEndAllowThreads(__tstate);
19461 if (PyErr_Occurred()) SWIG_fail;
19462 }
19463 resultobj = SWIG_Py_Void();
19464 return resultobj;
19465 fail:
19466 return NULL;
19467 }
19468
19469
19470 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19471 PyObject *resultobj = 0;
19472 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19473 wxEvent *result = 0 ;
19474 void *argp1 = 0 ;
19475 int res1 = 0 ;
19476 PyObject *swig_obj[1] ;
19477
19478 if (!args) SWIG_fail;
19479 swig_obj[0] = args;
19480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19481 if (!SWIG_IsOK(res1)) {
19482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19483 }
19484 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19485 {
19486 PyThreadState* __tstate = wxPyBeginAllowThreads();
19487 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19488 wxPyEndAllowThreads(__tstate);
19489 if (PyErr_Occurred()) SWIG_fail;
19490 }
19491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19492 return resultobj;
19493 fail:
19494 return NULL;
19495 }
19496
19497
19498 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19499 PyObject *obj;
19500 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19501 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19502 return SWIG_Py_Void();
19503 }
19504
19505 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19506 return SWIG_Python_InitShadowInstance(args);
19507 }
19508
19509 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19510 PyObject *resultobj = 0;
19511 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19512 int arg2 = (int) 0 ;
19513 wxNotifyEvent *result = 0 ;
19514 int val1 ;
19515 int ecode1 = 0 ;
19516 int val2 ;
19517 int ecode2 = 0 ;
19518 PyObject * obj0 = 0 ;
19519 PyObject * obj1 = 0 ;
19520 char * kwnames[] = {
19521 (char *) "commandType",(char *) "winid", NULL
19522 };
19523
19524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19525 if (obj0) {
19526 ecode1 = SWIG_AsVal_int(obj0, &val1);
19527 if (!SWIG_IsOK(ecode1)) {
19528 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19529 }
19530 arg1 = static_cast< wxEventType >(val1);
19531 }
19532 if (obj1) {
19533 ecode2 = SWIG_AsVal_int(obj1, &val2);
19534 if (!SWIG_IsOK(ecode2)) {
19535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19536 }
19537 arg2 = static_cast< int >(val2);
19538 }
19539 {
19540 PyThreadState* __tstate = wxPyBeginAllowThreads();
19541 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19542 wxPyEndAllowThreads(__tstate);
19543 if (PyErr_Occurred()) SWIG_fail;
19544 }
19545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19546 return resultobj;
19547 fail:
19548 return NULL;
19549 }
19550
19551
19552 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19553 PyObject *resultobj = 0;
19554 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19555 void *argp1 = 0 ;
19556 int res1 = 0 ;
19557 PyObject *swig_obj[1] ;
19558
19559 if (!args) SWIG_fail;
19560 swig_obj[0] = args;
19561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19562 if (!SWIG_IsOK(res1)) {
19563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19564 }
19565 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19566 {
19567 PyThreadState* __tstate = wxPyBeginAllowThreads();
19568 (arg1)->Veto();
19569 wxPyEndAllowThreads(__tstate);
19570 if (PyErr_Occurred()) SWIG_fail;
19571 }
19572 resultobj = SWIG_Py_Void();
19573 return resultobj;
19574 fail:
19575 return NULL;
19576 }
19577
19578
19579 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19580 PyObject *resultobj = 0;
19581 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19582 void *argp1 = 0 ;
19583 int res1 = 0 ;
19584 PyObject *swig_obj[1] ;
19585
19586 if (!args) SWIG_fail;
19587 swig_obj[0] = args;
19588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19589 if (!SWIG_IsOK(res1)) {
19590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19591 }
19592 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19593 {
19594 PyThreadState* __tstate = wxPyBeginAllowThreads();
19595 (arg1)->Allow();
19596 wxPyEndAllowThreads(__tstate);
19597 if (PyErr_Occurred()) SWIG_fail;
19598 }
19599 resultobj = SWIG_Py_Void();
19600 return resultobj;
19601 fail:
19602 return NULL;
19603 }
19604
19605
19606 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19607 PyObject *resultobj = 0;
19608 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19609 bool result;
19610 void *argp1 = 0 ;
19611 int res1 = 0 ;
19612 PyObject *swig_obj[1] ;
19613
19614 if (!args) SWIG_fail;
19615 swig_obj[0] = args;
19616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19617 if (!SWIG_IsOK(res1)) {
19618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19619 }
19620 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19621 {
19622 PyThreadState* __tstate = wxPyBeginAllowThreads();
19623 result = (bool)(arg1)->IsAllowed();
19624 wxPyEndAllowThreads(__tstate);
19625 if (PyErr_Occurred()) SWIG_fail;
19626 }
19627 {
19628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19629 }
19630 return resultobj;
19631 fail:
19632 return NULL;
19633 }
19634
19635
19636 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19637 PyObject *obj;
19638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19639 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19640 return SWIG_Py_Void();
19641 }
19642
19643 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19644 return SWIG_Python_InitShadowInstance(args);
19645 }
19646
19647 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19648 PyObject *resultobj = 0;
19649 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19650 int arg2 = (int) 0 ;
19651 int arg3 = (int) 0 ;
19652 int arg4 = (int) 0 ;
19653 wxScrollEvent *result = 0 ;
19654 int val1 ;
19655 int ecode1 = 0 ;
19656 int val2 ;
19657 int ecode2 = 0 ;
19658 int val3 ;
19659 int ecode3 = 0 ;
19660 int val4 ;
19661 int ecode4 = 0 ;
19662 PyObject * obj0 = 0 ;
19663 PyObject * obj1 = 0 ;
19664 PyObject * obj2 = 0 ;
19665 PyObject * obj3 = 0 ;
19666 char * kwnames[] = {
19667 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19668 };
19669
19670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19671 if (obj0) {
19672 ecode1 = SWIG_AsVal_int(obj0, &val1);
19673 if (!SWIG_IsOK(ecode1)) {
19674 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19675 }
19676 arg1 = static_cast< wxEventType >(val1);
19677 }
19678 if (obj1) {
19679 ecode2 = SWIG_AsVal_int(obj1, &val2);
19680 if (!SWIG_IsOK(ecode2)) {
19681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19682 }
19683 arg2 = static_cast< int >(val2);
19684 }
19685 if (obj2) {
19686 ecode3 = SWIG_AsVal_int(obj2, &val3);
19687 if (!SWIG_IsOK(ecode3)) {
19688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19689 }
19690 arg3 = static_cast< int >(val3);
19691 }
19692 if (obj3) {
19693 ecode4 = SWIG_AsVal_int(obj3, &val4);
19694 if (!SWIG_IsOK(ecode4)) {
19695 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19696 }
19697 arg4 = static_cast< int >(val4);
19698 }
19699 {
19700 PyThreadState* __tstate = wxPyBeginAllowThreads();
19701 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19702 wxPyEndAllowThreads(__tstate);
19703 if (PyErr_Occurred()) SWIG_fail;
19704 }
19705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19706 return resultobj;
19707 fail:
19708 return NULL;
19709 }
19710
19711
19712 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19713 PyObject *resultobj = 0;
19714 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19715 int result;
19716 void *argp1 = 0 ;
19717 int res1 = 0 ;
19718 PyObject *swig_obj[1] ;
19719
19720 if (!args) SWIG_fail;
19721 swig_obj[0] = args;
19722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19723 if (!SWIG_IsOK(res1)) {
19724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19725 }
19726 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19727 {
19728 PyThreadState* __tstate = wxPyBeginAllowThreads();
19729 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19730 wxPyEndAllowThreads(__tstate);
19731 if (PyErr_Occurred()) SWIG_fail;
19732 }
19733 resultobj = SWIG_From_int(static_cast< int >(result));
19734 return resultobj;
19735 fail:
19736 return NULL;
19737 }
19738
19739
19740 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19741 PyObject *resultobj = 0;
19742 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19743 int result;
19744 void *argp1 = 0 ;
19745 int res1 = 0 ;
19746 PyObject *swig_obj[1] ;
19747
19748 if (!args) SWIG_fail;
19749 swig_obj[0] = args;
19750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19751 if (!SWIG_IsOK(res1)) {
19752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19753 }
19754 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19755 {
19756 PyThreadState* __tstate = wxPyBeginAllowThreads();
19757 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19758 wxPyEndAllowThreads(__tstate);
19759 if (PyErr_Occurred()) SWIG_fail;
19760 }
19761 resultobj = SWIG_From_int(static_cast< int >(result));
19762 return resultobj;
19763 fail:
19764 return NULL;
19765 }
19766
19767
19768 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19769 PyObject *resultobj = 0;
19770 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19771 int arg2 ;
19772 void *argp1 = 0 ;
19773 int res1 = 0 ;
19774 int val2 ;
19775 int ecode2 = 0 ;
19776 PyObject * obj0 = 0 ;
19777 PyObject * obj1 = 0 ;
19778 char * kwnames[] = {
19779 (char *) "self",(char *) "orient", NULL
19780 };
19781
19782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19784 if (!SWIG_IsOK(res1)) {
19785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19786 }
19787 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19788 ecode2 = SWIG_AsVal_int(obj1, &val2);
19789 if (!SWIG_IsOK(ecode2)) {
19790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19791 }
19792 arg2 = static_cast< int >(val2);
19793 {
19794 PyThreadState* __tstate = wxPyBeginAllowThreads();
19795 (arg1)->SetOrientation(arg2);
19796 wxPyEndAllowThreads(__tstate);
19797 if (PyErr_Occurred()) SWIG_fail;
19798 }
19799 resultobj = SWIG_Py_Void();
19800 return resultobj;
19801 fail:
19802 return NULL;
19803 }
19804
19805
19806 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19807 PyObject *resultobj = 0;
19808 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19809 int arg2 ;
19810 void *argp1 = 0 ;
19811 int res1 = 0 ;
19812 int val2 ;
19813 int ecode2 = 0 ;
19814 PyObject * obj0 = 0 ;
19815 PyObject * obj1 = 0 ;
19816 char * kwnames[] = {
19817 (char *) "self",(char *) "pos", NULL
19818 };
19819
19820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19822 if (!SWIG_IsOK(res1)) {
19823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19824 }
19825 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19826 ecode2 = SWIG_AsVal_int(obj1, &val2);
19827 if (!SWIG_IsOK(ecode2)) {
19828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19829 }
19830 arg2 = static_cast< int >(val2);
19831 {
19832 PyThreadState* __tstate = wxPyBeginAllowThreads();
19833 (arg1)->SetPosition(arg2);
19834 wxPyEndAllowThreads(__tstate);
19835 if (PyErr_Occurred()) SWIG_fail;
19836 }
19837 resultobj = SWIG_Py_Void();
19838 return resultobj;
19839 fail:
19840 return NULL;
19841 }
19842
19843
19844 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19845 PyObject *obj;
19846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19847 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19848 return SWIG_Py_Void();
19849 }
19850
19851 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19852 return SWIG_Python_InitShadowInstance(args);
19853 }
19854
19855 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19856 PyObject *resultobj = 0;
19857 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19858 int arg2 = (int) 0 ;
19859 int arg3 = (int) 0 ;
19860 wxScrollWinEvent *result = 0 ;
19861 int val1 ;
19862 int ecode1 = 0 ;
19863 int val2 ;
19864 int ecode2 = 0 ;
19865 int val3 ;
19866 int ecode3 = 0 ;
19867 PyObject * obj0 = 0 ;
19868 PyObject * obj1 = 0 ;
19869 PyObject * obj2 = 0 ;
19870 char * kwnames[] = {
19871 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19872 };
19873
19874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19875 if (obj0) {
19876 ecode1 = SWIG_AsVal_int(obj0, &val1);
19877 if (!SWIG_IsOK(ecode1)) {
19878 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19879 }
19880 arg1 = static_cast< wxEventType >(val1);
19881 }
19882 if (obj1) {
19883 ecode2 = SWIG_AsVal_int(obj1, &val2);
19884 if (!SWIG_IsOK(ecode2)) {
19885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19886 }
19887 arg2 = static_cast< int >(val2);
19888 }
19889 if (obj2) {
19890 ecode3 = SWIG_AsVal_int(obj2, &val3);
19891 if (!SWIG_IsOK(ecode3)) {
19892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19893 }
19894 arg3 = static_cast< int >(val3);
19895 }
19896 {
19897 PyThreadState* __tstate = wxPyBeginAllowThreads();
19898 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19899 wxPyEndAllowThreads(__tstate);
19900 if (PyErr_Occurred()) SWIG_fail;
19901 }
19902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19903 return resultobj;
19904 fail:
19905 return NULL;
19906 }
19907
19908
19909 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19910 PyObject *resultobj = 0;
19911 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19912 int result;
19913 void *argp1 = 0 ;
19914 int res1 = 0 ;
19915 PyObject *swig_obj[1] ;
19916
19917 if (!args) SWIG_fail;
19918 swig_obj[0] = args;
19919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19920 if (!SWIG_IsOK(res1)) {
19921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19922 }
19923 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19924 {
19925 PyThreadState* __tstate = wxPyBeginAllowThreads();
19926 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19927 wxPyEndAllowThreads(__tstate);
19928 if (PyErr_Occurred()) SWIG_fail;
19929 }
19930 resultobj = SWIG_From_int(static_cast< int >(result));
19931 return resultobj;
19932 fail:
19933 return NULL;
19934 }
19935
19936
19937 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19938 PyObject *resultobj = 0;
19939 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19940 int result;
19941 void *argp1 = 0 ;
19942 int res1 = 0 ;
19943 PyObject *swig_obj[1] ;
19944
19945 if (!args) SWIG_fail;
19946 swig_obj[0] = args;
19947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19948 if (!SWIG_IsOK(res1)) {
19949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19950 }
19951 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19952 {
19953 PyThreadState* __tstate = wxPyBeginAllowThreads();
19954 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19955 wxPyEndAllowThreads(__tstate);
19956 if (PyErr_Occurred()) SWIG_fail;
19957 }
19958 resultobj = SWIG_From_int(static_cast< int >(result));
19959 return resultobj;
19960 fail:
19961 return NULL;
19962 }
19963
19964
19965 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19966 PyObject *resultobj = 0;
19967 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19968 int arg2 ;
19969 void *argp1 = 0 ;
19970 int res1 = 0 ;
19971 int val2 ;
19972 int ecode2 = 0 ;
19973 PyObject * obj0 = 0 ;
19974 PyObject * obj1 = 0 ;
19975 char * kwnames[] = {
19976 (char *) "self",(char *) "orient", NULL
19977 };
19978
19979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19981 if (!SWIG_IsOK(res1)) {
19982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19983 }
19984 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19985 ecode2 = SWIG_AsVal_int(obj1, &val2);
19986 if (!SWIG_IsOK(ecode2)) {
19987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19988 }
19989 arg2 = static_cast< int >(val2);
19990 {
19991 PyThreadState* __tstate = wxPyBeginAllowThreads();
19992 (arg1)->SetOrientation(arg2);
19993 wxPyEndAllowThreads(__tstate);
19994 if (PyErr_Occurred()) SWIG_fail;
19995 }
19996 resultobj = SWIG_Py_Void();
19997 return resultobj;
19998 fail:
19999 return NULL;
20000 }
20001
20002
20003 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20004 PyObject *resultobj = 0;
20005 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20006 int arg2 ;
20007 void *argp1 = 0 ;
20008 int res1 = 0 ;
20009 int val2 ;
20010 int ecode2 = 0 ;
20011 PyObject * obj0 = 0 ;
20012 PyObject * obj1 = 0 ;
20013 char * kwnames[] = {
20014 (char *) "self",(char *) "pos", NULL
20015 };
20016
20017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20019 if (!SWIG_IsOK(res1)) {
20020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20021 }
20022 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20023 ecode2 = SWIG_AsVal_int(obj1, &val2);
20024 if (!SWIG_IsOK(ecode2)) {
20025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20026 }
20027 arg2 = static_cast< int >(val2);
20028 {
20029 PyThreadState* __tstate = wxPyBeginAllowThreads();
20030 (arg1)->SetPosition(arg2);
20031 wxPyEndAllowThreads(__tstate);
20032 if (PyErr_Occurred()) SWIG_fail;
20033 }
20034 resultobj = SWIG_Py_Void();
20035 return resultobj;
20036 fail:
20037 return NULL;
20038 }
20039
20040
20041 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20042 PyObject *obj;
20043 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20044 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20045 return SWIG_Py_Void();
20046 }
20047
20048 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20049 return SWIG_Python_InitShadowInstance(args);
20050 }
20051
20052 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20053 PyObject *resultobj = 0;
20054 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20055 wxMouseEvent *result = 0 ;
20056 int val1 ;
20057 int ecode1 = 0 ;
20058 PyObject * obj0 = 0 ;
20059 char * kwnames[] = {
20060 (char *) "mouseType", NULL
20061 };
20062
20063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20064 if (obj0) {
20065 ecode1 = SWIG_AsVal_int(obj0, &val1);
20066 if (!SWIG_IsOK(ecode1)) {
20067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20068 }
20069 arg1 = static_cast< wxEventType >(val1);
20070 }
20071 {
20072 PyThreadState* __tstate = wxPyBeginAllowThreads();
20073 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20074 wxPyEndAllowThreads(__tstate);
20075 if (PyErr_Occurred()) SWIG_fail;
20076 }
20077 {
20078 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20079 }
20080 return resultobj;
20081 fail:
20082 return NULL;
20083 }
20084
20085
20086 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20087 PyObject *resultobj = 0;
20088 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20089 bool result;
20090 void *argp1 = 0 ;
20091 int res1 = 0 ;
20092 PyObject *swig_obj[1] ;
20093
20094 if (!args) SWIG_fail;
20095 swig_obj[0] = args;
20096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20097 if (!SWIG_IsOK(res1)) {
20098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20099 }
20100 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20101 {
20102 PyThreadState* __tstate = wxPyBeginAllowThreads();
20103 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20104 wxPyEndAllowThreads(__tstate);
20105 if (PyErr_Occurred()) SWIG_fail;
20106 }
20107 {
20108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20109 }
20110 return resultobj;
20111 fail:
20112 return NULL;
20113 }
20114
20115
20116 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20117 PyObject *resultobj = 0;
20118 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20119 int arg2 = (int) wxMOUSE_BTN_ANY ;
20120 bool result;
20121 void *argp1 = 0 ;
20122 int res1 = 0 ;
20123 int val2 ;
20124 int ecode2 = 0 ;
20125 PyObject * obj0 = 0 ;
20126 PyObject * obj1 = 0 ;
20127 char * kwnames[] = {
20128 (char *) "self",(char *) "but", NULL
20129 };
20130
20131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20133 if (!SWIG_IsOK(res1)) {
20134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20135 }
20136 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20137 if (obj1) {
20138 ecode2 = SWIG_AsVal_int(obj1, &val2);
20139 if (!SWIG_IsOK(ecode2)) {
20140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20141 }
20142 arg2 = static_cast< int >(val2);
20143 }
20144 {
20145 PyThreadState* __tstate = wxPyBeginAllowThreads();
20146 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20147 wxPyEndAllowThreads(__tstate);
20148 if (PyErr_Occurred()) SWIG_fail;
20149 }
20150 {
20151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20152 }
20153 return resultobj;
20154 fail:
20155 return NULL;
20156 }
20157
20158
20159 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20160 PyObject *resultobj = 0;
20161 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20162 int arg2 = (int) wxMOUSE_BTN_ANY ;
20163 bool result;
20164 void *argp1 = 0 ;
20165 int res1 = 0 ;
20166 int val2 ;
20167 int ecode2 = 0 ;
20168 PyObject * obj0 = 0 ;
20169 PyObject * obj1 = 0 ;
20170 char * kwnames[] = {
20171 (char *) "self",(char *) "but", NULL
20172 };
20173
20174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20176 if (!SWIG_IsOK(res1)) {
20177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20178 }
20179 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20180 if (obj1) {
20181 ecode2 = SWIG_AsVal_int(obj1, &val2);
20182 if (!SWIG_IsOK(ecode2)) {
20183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20184 }
20185 arg2 = static_cast< int >(val2);
20186 }
20187 {
20188 PyThreadState* __tstate = wxPyBeginAllowThreads();
20189 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20190 wxPyEndAllowThreads(__tstate);
20191 if (PyErr_Occurred()) SWIG_fail;
20192 }
20193 {
20194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20195 }
20196 return resultobj;
20197 fail:
20198 return NULL;
20199 }
20200
20201
20202 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20203 PyObject *resultobj = 0;
20204 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20205 int arg2 = (int) wxMOUSE_BTN_ANY ;
20206 bool result;
20207 void *argp1 = 0 ;
20208 int res1 = 0 ;
20209 int val2 ;
20210 int ecode2 = 0 ;
20211 PyObject * obj0 = 0 ;
20212 PyObject * obj1 = 0 ;
20213 char * kwnames[] = {
20214 (char *) "self",(char *) "but", NULL
20215 };
20216
20217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20219 if (!SWIG_IsOK(res1)) {
20220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20221 }
20222 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20223 if (obj1) {
20224 ecode2 = SWIG_AsVal_int(obj1, &val2);
20225 if (!SWIG_IsOK(ecode2)) {
20226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20227 }
20228 arg2 = static_cast< int >(val2);
20229 }
20230 {
20231 PyThreadState* __tstate = wxPyBeginAllowThreads();
20232 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20233 wxPyEndAllowThreads(__tstate);
20234 if (PyErr_Occurred()) SWIG_fail;
20235 }
20236 {
20237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20238 }
20239 return resultobj;
20240 fail:
20241 return NULL;
20242 }
20243
20244
20245 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20246 PyObject *resultobj = 0;
20247 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20248 int arg2 ;
20249 bool result;
20250 void *argp1 = 0 ;
20251 int res1 = 0 ;
20252 int val2 ;
20253 int ecode2 = 0 ;
20254 PyObject * obj0 = 0 ;
20255 PyObject * obj1 = 0 ;
20256 char * kwnames[] = {
20257 (char *) "self",(char *) "button", NULL
20258 };
20259
20260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20262 if (!SWIG_IsOK(res1)) {
20263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20264 }
20265 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20266 ecode2 = SWIG_AsVal_int(obj1, &val2);
20267 if (!SWIG_IsOK(ecode2)) {
20268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20269 }
20270 arg2 = static_cast< int >(val2);
20271 {
20272 PyThreadState* __tstate = wxPyBeginAllowThreads();
20273 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20274 wxPyEndAllowThreads(__tstate);
20275 if (PyErr_Occurred()) SWIG_fail;
20276 }
20277 {
20278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20279 }
20280 return resultobj;
20281 fail:
20282 return NULL;
20283 }
20284
20285
20286 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20287 PyObject *resultobj = 0;
20288 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20289 int arg2 ;
20290 bool result;
20291 void *argp1 = 0 ;
20292 int res1 = 0 ;
20293 int val2 ;
20294 int ecode2 = 0 ;
20295 PyObject * obj0 = 0 ;
20296 PyObject * obj1 = 0 ;
20297 char * kwnames[] = {
20298 (char *) "self",(char *) "but", NULL
20299 };
20300
20301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20303 if (!SWIG_IsOK(res1)) {
20304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20305 }
20306 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20307 ecode2 = SWIG_AsVal_int(obj1, &val2);
20308 if (!SWIG_IsOK(ecode2)) {
20309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20310 }
20311 arg2 = static_cast< int >(val2);
20312 {
20313 PyThreadState* __tstate = wxPyBeginAllowThreads();
20314 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20315 wxPyEndAllowThreads(__tstate);
20316 if (PyErr_Occurred()) SWIG_fail;
20317 }
20318 {
20319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20320 }
20321 return resultobj;
20322 fail:
20323 return NULL;
20324 }
20325
20326
20327 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20328 PyObject *resultobj = 0;
20329 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20330 int result;
20331 void *argp1 = 0 ;
20332 int res1 = 0 ;
20333 PyObject *swig_obj[1] ;
20334
20335 if (!args) SWIG_fail;
20336 swig_obj[0] = args;
20337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20338 if (!SWIG_IsOK(res1)) {
20339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20340 }
20341 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20342 {
20343 PyThreadState* __tstate = wxPyBeginAllowThreads();
20344 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20345 wxPyEndAllowThreads(__tstate);
20346 if (PyErr_Occurred()) SWIG_fail;
20347 }
20348 resultobj = SWIG_From_int(static_cast< int >(result));
20349 return resultobj;
20350 fail:
20351 return NULL;
20352 }
20353
20354
20355 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20356 PyObject *resultobj = 0;
20357 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20358 bool result;
20359 void *argp1 = 0 ;
20360 int res1 = 0 ;
20361 PyObject *swig_obj[1] ;
20362
20363 if (!args) SWIG_fail;
20364 swig_obj[0] = args;
20365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20366 if (!SWIG_IsOK(res1)) {
20367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20368 }
20369 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20370 {
20371 PyThreadState* __tstate = wxPyBeginAllowThreads();
20372 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20373 wxPyEndAllowThreads(__tstate);
20374 if (PyErr_Occurred()) SWIG_fail;
20375 }
20376 {
20377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20378 }
20379 return resultobj;
20380 fail:
20381 return NULL;
20382 }
20383
20384
20385 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20386 PyObject *resultobj = 0;
20387 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20388 bool result;
20389 void *argp1 = 0 ;
20390 int res1 = 0 ;
20391 PyObject *swig_obj[1] ;
20392
20393 if (!args) SWIG_fail;
20394 swig_obj[0] = args;
20395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20396 if (!SWIG_IsOK(res1)) {
20397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20398 }
20399 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20400 {
20401 PyThreadState* __tstate = wxPyBeginAllowThreads();
20402 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20403 wxPyEndAllowThreads(__tstate);
20404 if (PyErr_Occurred()) SWIG_fail;
20405 }
20406 {
20407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20408 }
20409 return resultobj;
20410 fail:
20411 return NULL;
20412 }
20413
20414
20415 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20416 PyObject *resultobj = 0;
20417 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20418 bool result;
20419 void *argp1 = 0 ;
20420 int res1 = 0 ;
20421 PyObject *swig_obj[1] ;
20422
20423 if (!args) SWIG_fail;
20424 swig_obj[0] = args;
20425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20426 if (!SWIG_IsOK(res1)) {
20427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20428 }
20429 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20430 {
20431 PyThreadState* __tstate = wxPyBeginAllowThreads();
20432 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20433 wxPyEndAllowThreads(__tstate);
20434 if (PyErr_Occurred()) SWIG_fail;
20435 }
20436 {
20437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20438 }
20439 return resultobj;
20440 fail:
20441 return NULL;
20442 }
20443
20444
20445 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20446 PyObject *resultobj = 0;
20447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20448 bool result;
20449 void *argp1 = 0 ;
20450 int res1 = 0 ;
20451 PyObject *swig_obj[1] ;
20452
20453 if (!args) SWIG_fail;
20454 swig_obj[0] = args;
20455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20456 if (!SWIG_IsOK(res1)) {
20457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20458 }
20459 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20460 {
20461 PyThreadState* __tstate = wxPyBeginAllowThreads();
20462 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20463 wxPyEndAllowThreads(__tstate);
20464 if (PyErr_Occurred()) SWIG_fail;
20465 }
20466 {
20467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20468 }
20469 return resultobj;
20470 fail:
20471 return NULL;
20472 }
20473
20474
20475 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20476 PyObject *resultobj = 0;
20477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20478 bool result;
20479 void *argp1 = 0 ;
20480 int res1 = 0 ;
20481 PyObject *swig_obj[1] ;
20482
20483 if (!args) SWIG_fail;
20484 swig_obj[0] = args;
20485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20486 if (!SWIG_IsOK(res1)) {
20487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20488 }
20489 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20490 {
20491 PyThreadState* __tstate = wxPyBeginAllowThreads();
20492 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20493 wxPyEndAllowThreads(__tstate);
20494 if (PyErr_Occurred()) SWIG_fail;
20495 }
20496 {
20497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20498 }
20499 return resultobj;
20500 fail:
20501 return NULL;
20502 }
20503
20504
20505 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20506 PyObject *resultobj = 0;
20507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20508 bool result;
20509 void *argp1 = 0 ;
20510 int res1 = 0 ;
20511 PyObject *swig_obj[1] ;
20512
20513 if (!args) SWIG_fail;
20514 swig_obj[0] = args;
20515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20516 if (!SWIG_IsOK(res1)) {
20517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20518 }
20519 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20520 {
20521 PyThreadState* __tstate = wxPyBeginAllowThreads();
20522 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20523 wxPyEndAllowThreads(__tstate);
20524 if (PyErr_Occurred()) SWIG_fail;
20525 }
20526 {
20527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20528 }
20529 return resultobj;
20530 fail:
20531 return NULL;
20532 }
20533
20534
20535 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20536 PyObject *resultobj = 0;
20537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20538 bool result;
20539 void *argp1 = 0 ;
20540 int res1 = 0 ;
20541 PyObject *swig_obj[1] ;
20542
20543 if (!args) SWIG_fail;
20544 swig_obj[0] = args;
20545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20546 if (!SWIG_IsOK(res1)) {
20547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20548 }
20549 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20550 {
20551 PyThreadState* __tstate = wxPyBeginAllowThreads();
20552 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20553 wxPyEndAllowThreads(__tstate);
20554 if (PyErr_Occurred()) SWIG_fail;
20555 }
20556 {
20557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20558 }
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20566 PyObject *resultobj = 0;
20567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20568 bool result;
20569 void *argp1 = 0 ;
20570 int res1 = 0 ;
20571 PyObject *swig_obj[1] ;
20572
20573 if (!args) SWIG_fail;
20574 swig_obj[0] = args;
20575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20576 if (!SWIG_IsOK(res1)) {
20577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20578 }
20579 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20580 {
20581 PyThreadState* __tstate = wxPyBeginAllowThreads();
20582 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20583 wxPyEndAllowThreads(__tstate);
20584 if (PyErr_Occurred()) SWIG_fail;
20585 }
20586 {
20587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20588 }
20589 return resultobj;
20590 fail:
20591 return NULL;
20592 }
20593
20594
20595 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20596 PyObject *resultobj = 0;
20597 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20598 bool result;
20599 void *argp1 = 0 ;
20600 int res1 = 0 ;
20601 PyObject *swig_obj[1] ;
20602
20603 if (!args) SWIG_fail;
20604 swig_obj[0] = args;
20605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20606 if (!SWIG_IsOK(res1)) {
20607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20608 }
20609 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20610 {
20611 PyThreadState* __tstate = wxPyBeginAllowThreads();
20612 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20613 wxPyEndAllowThreads(__tstate);
20614 if (PyErr_Occurred()) SWIG_fail;
20615 }
20616 {
20617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20618 }
20619 return resultobj;
20620 fail:
20621 return NULL;
20622 }
20623
20624
20625 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20626 PyObject *resultobj = 0;
20627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20628 bool result;
20629 void *argp1 = 0 ;
20630 int res1 = 0 ;
20631 PyObject *swig_obj[1] ;
20632
20633 if (!args) SWIG_fail;
20634 swig_obj[0] = args;
20635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20636 if (!SWIG_IsOK(res1)) {
20637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20638 }
20639 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20640 {
20641 PyThreadState* __tstate = wxPyBeginAllowThreads();
20642 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20643 wxPyEndAllowThreads(__tstate);
20644 if (PyErr_Occurred()) SWIG_fail;
20645 }
20646 {
20647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20648 }
20649 return resultobj;
20650 fail:
20651 return NULL;
20652 }
20653
20654
20655 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20656 PyObject *resultobj = 0;
20657 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20658 bool result;
20659 void *argp1 = 0 ;
20660 int res1 = 0 ;
20661 PyObject *swig_obj[1] ;
20662
20663 if (!args) SWIG_fail;
20664 swig_obj[0] = args;
20665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20666 if (!SWIG_IsOK(res1)) {
20667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20668 }
20669 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20670 {
20671 PyThreadState* __tstate = wxPyBeginAllowThreads();
20672 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20673 wxPyEndAllowThreads(__tstate);
20674 if (PyErr_Occurred()) SWIG_fail;
20675 }
20676 {
20677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20678 }
20679 return resultobj;
20680 fail:
20681 return NULL;
20682 }
20683
20684
20685 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20686 PyObject *resultobj = 0;
20687 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20688 bool result;
20689 void *argp1 = 0 ;
20690 int res1 = 0 ;
20691 PyObject *swig_obj[1] ;
20692
20693 if (!args) SWIG_fail;
20694 swig_obj[0] = args;
20695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20696 if (!SWIG_IsOK(res1)) {
20697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20698 }
20699 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20700 {
20701 PyThreadState* __tstate = wxPyBeginAllowThreads();
20702 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20703 wxPyEndAllowThreads(__tstate);
20704 if (PyErr_Occurred()) SWIG_fail;
20705 }
20706 {
20707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20708 }
20709 return resultobj;
20710 fail:
20711 return NULL;
20712 }
20713
20714
20715 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20716 PyObject *resultobj = 0;
20717 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20718 bool result;
20719 void *argp1 = 0 ;
20720 int res1 = 0 ;
20721 PyObject *swig_obj[1] ;
20722
20723 if (!args) SWIG_fail;
20724 swig_obj[0] = args;
20725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20726 if (!SWIG_IsOK(res1)) {
20727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20728 }
20729 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20730 {
20731 PyThreadState* __tstate = wxPyBeginAllowThreads();
20732 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 {
20737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20738 }
20739 return resultobj;
20740 fail:
20741 return NULL;
20742 }
20743
20744
20745 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20746 PyObject *resultobj = 0;
20747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20748 bool result;
20749 void *argp1 = 0 ;
20750 int res1 = 0 ;
20751 PyObject *swig_obj[1] ;
20752
20753 if (!args) SWIG_fail;
20754 swig_obj[0] = args;
20755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20756 if (!SWIG_IsOK(res1)) {
20757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20758 }
20759 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20760 {
20761 PyThreadState* __tstate = wxPyBeginAllowThreads();
20762 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20763 wxPyEndAllowThreads(__tstate);
20764 if (PyErr_Occurred()) SWIG_fail;
20765 }
20766 {
20767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20768 }
20769 return resultobj;
20770 fail:
20771 return NULL;
20772 }
20773
20774
20775 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20776 PyObject *resultobj = 0;
20777 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20778 bool result;
20779 void *argp1 = 0 ;
20780 int res1 = 0 ;
20781 PyObject *swig_obj[1] ;
20782
20783 if (!args) SWIG_fail;
20784 swig_obj[0] = args;
20785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20786 if (!SWIG_IsOK(res1)) {
20787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20788 }
20789 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20790 {
20791 PyThreadState* __tstate = wxPyBeginAllowThreads();
20792 result = (bool)(arg1)->LeftIsDown();
20793 wxPyEndAllowThreads(__tstate);
20794 if (PyErr_Occurred()) SWIG_fail;
20795 }
20796 {
20797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20798 }
20799 return resultobj;
20800 fail:
20801 return NULL;
20802 }
20803
20804
20805 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20806 PyObject *resultobj = 0;
20807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20808 bool result;
20809 void *argp1 = 0 ;
20810 int res1 = 0 ;
20811 PyObject *swig_obj[1] ;
20812
20813 if (!args) SWIG_fail;
20814 swig_obj[0] = args;
20815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20816 if (!SWIG_IsOK(res1)) {
20817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20818 }
20819 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20820 {
20821 PyThreadState* __tstate = wxPyBeginAllowThreads();
20822 result = (bool)(arg1)->MiddleIsDown();
20823 wxPyEndAllowThreads(__tstate);
20824 if (PyErr_Occurred()) SWIG_fail;
20825 }
20826 {
20827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20828 }
20829 return resultobj;
20830 fail:
20831 return NULL;
20832 }
20833
20834
20835 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20836 PyObject *resultobj = 0;
20837 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20838 bool result;
20839 void *argp1 = 0 ;
20840 int res1 = 0 ;
20841 PyObject *swig_obj[1] ;
20842
20843 if (!args) SWIG_fail;
20844 swig_obj[0] = args;
20845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20846 if (!SWIG_IsOK(res1)) {
20847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20848 }
20849 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20850 {
20851 PyThreadState* __tstate = wxPyBeginAllowThreads();
20852 result = (bool)(arg1)->RightIsDown();
20853 wxPyEndAllowThreads(__tstate);
20854 if (PyErr_Occurred()) SWIG_fail;
20855 }
20856 {
20857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20858 }
20859 return resultobj;
20860 fail:
20861 return NULL;
20862 }
20863
20864
20865 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(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_Dragging" "', 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)->Dragging();
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_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20896 PyObject *resultobj = 0;
20897 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20898 bool result;
20899 void *argp1 = 0 ;
20900 int res1 = 0 ;
20901 PyObject *swig_obj[1] ;
20902
20903 if (!args) SWIG_fail;
20904 swig_obj[0] = args;
20905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20906 if (!SWIG_IsOK(res1)) {
20907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20908 }
20909 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20910 {
20911 PyThreadState* __tstate = wxPyBeginAllowThreads();
20912 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20913 wxPyEndAllowThreads(__tstate);
20914 if (PyErr_Occurred()) SWIG_fail;
20915 }
20916 {
20917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20918 }
20919 return resultobj;
20920 fail:
20921 return NULL;
20922 }
20923
20924
20925 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20926 PyObject *resultobj = 0;
20927 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20928 bool 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_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20938 }
20939 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20940 {
20941 PyThreadState* __tstate = wxPyBeginAllowThreads();
20942 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20943 wxPyEndAllowThreads(__tstate);
20944 if (PyErr_Occurred()) SWIG_fail;
20945 }
20946 {
20947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20948 }
20949 return resultobj;
20950 fail:
20951 return NULL;
20952 }
20953
20954
20955 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20956 PyObject *resultobj = 0;
20957 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20958 bool result;
20959 void *argp1 = 0 ;
20960 int res1 = 0 ;
20961 PyObject *swig_obj[1] ;
20962
20963 if (!args) SWIG_fail;
20964 swig_obj[0] = args;
20965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20966 if (!SWIG_IsOK(res1)) {
20967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20968 }
20969 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20970 {
20971 PyThreadState* __tstate = wxPyBeginAllowThreads();
20972 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20973 wxPyEndAllowThreads(__tstate);
20974 if (PyErr_Occurred()) SWIG_fail;
20975 }
20976 {
20977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20978 }
20979 return resultobj;
20980 fail:
20981 return NULL;
20982 }
20983
20984
20985 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20986 PyObject *resultobj = 0;
20987 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20988 wxPoint result;
20989 void *argp1 = 0 ;
20990 int res1 = 0 ;
20991 PyObject *swig_obj[1] ;
20992
20993 if (!args) SWIG_fail;
20994 swig_obj[0] = args;
20995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20996 if (!SWIG_IsOK(res1)) {
20997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20998 }
20999 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21000 {
21001 PyThreadState* __tstate = wxPyBeginAllowThreads();
21002 result = (arg1)->GetPosition();
21003 wxPyEndAllowThreads(__tstate);
21004 if (PyErr_Occurred()) SWIG_fail;
21005 }
21006 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21007 return resultobj;
21008 fail:
21009 return NULL;
21010 }
21011
21012
21013 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21014 PyObject *resultobj = 0;
21015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21016 long *arg2 = (long *) 0 ;
21017 long *arg3 = (long *) 0 ;
21018 void *argp1 = 0 ;
21019 int res1 = 0 ;
21020 long temp2 ;
21021 int res2 = SWIG_TMPOBJ ;
21022 long temp3 ;
21023 int res3 = SWIG_TMPOBJ ;
21024 PyObject *swig_obj[1] ;
21025
21026 arg2 = &temp2;
21027 arg3 = &temp3;
21028 if (!args) SWIG_fail;
21029 swig_obj[0] = args;
21030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21031 if (!SWIG_IsOK(res1)) {
21032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21033 }
21034 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21035 {
21036 PyThreadState* __tstate = wxPyBeginAllowThreads();
21037 (arg1)->GetPosition(arg2,arg3);
21038 wxPyEndAllowThreads(__tstate);
21039 if (PyErr_Occurred()) SWIG_fail;
21040 }
21041 resultobj = SWIG_Py_Void();
21042 if (SWIG_IsTmpObj(res2)) {
21043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21044 } else {
21045 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21047 }
21048 if (SWIG_IsTmpObj(res3)) {
21049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21050 } else {
21051 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21053 }
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21061 PyObject *resultobj = 0;
21062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21063 wxDC *arg2 = 0 ;
21064 wxPoint result;
21065 void *argp1 = 0 ;
21066 int res1 = 0 ;
21067 void *argp2 = 0 ;
21068 int res2 = 0 ;
21069 PyObject * obj0 = 0 ;
21070 PyObject * obj1 = 0 ;
21071 char * kwnames[] = {
21072 (char *) "self",(char *) "dc", NULL
21073 };
21074
21075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21077 if (!SWIG_IsOK(res1)) {
21078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21079 }
21080 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21081 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21082 if (!SWIG_IsOK(res2)) {
21083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21084 }
21085 if (!argp2) {
21086 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21087 }
21088 arg2 = reinterpret_cast< wxDC * >(argp2);
21089 {
21090 PyThreadState* __tstate = wxPyBeginAllowThreads();
21091 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21092 wxPyEndAllowThreads(__tstate);
21093 if (PyErr_Occurred()) SWIG_fail;
21094 }
21095 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21096 return resultobj;
21097 fail:
21098 return NULL;
21099 }
21100
21101
21102 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21103 PyObject *resultobj = 0;
21104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21105 int result;
21106 void *argp1 = 0 ;
21107 int res1 = 0 ;
21108 PyObject *swig_obj[1] ;
21109
21110 if (!args) SWIG_fail;
21111 swig_obj[0] = args;
21112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21113 if (!SWIG_IsOK(res1)) {
21114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21115 }
21116 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21117 {
21118 PyThreadState* __tstate = wxPyBeginAllowThreads();
21119 result = (int)((wxMouseEvent const *)arg1)->GetX();
21120 wxPyEndAllowThreads(__tstate);
21121 if (PyErr_Occurred()) SWIG_fail;
21122 }
21123 resultobj = SWIG_From_int(static_cast< int >(result));
21124 return resultobj;
21125 fail:
21126 return NULL;
21127 }
21128
21129
21130 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21131 PyObject *resultobj = 0;
21132 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21133 int result;
21134 void *argp1 = 0 ;
21135 int res1 = 0 ;
21136 PyObject *swig_obj[1] ;
21137
21138 if (!args) SWIG_fail;
21139 swig_obj[0] = args;
21140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21141 if (!SWIG_IsOK(res1)) {
21142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21143 }
21144 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21145 {
21146 PyThreadState* __tstate = wxPyBeginAllowThreads();
21147 result = (int)((wxMouseEvent const *)arg1)->GetY();
21148 wxPyEndAllowThreads(__tstate);
21149 if (PyErr_Occurred()) SWIG_fail;
21150 }
21151 resultobj = SWIG_From_int(static_cast< int >(result));
21152 return resultobj;
21153 fail:
21154 return NULL;
21155 }
21156
21157
21158 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21159 PyObject *resultobj = 0;
21160 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21161 int result;
21162 void *argp1 = 0 ;
21163 int res1 = 0 ;
21164 PyObject *swig_obj[1] ;
21165
21166 if (!args) SWIG_fail;
21167 swig_obj[0] = args;
21168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21169 if (!SWIG_IsOK(res1)) {
21170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21171 }
21172 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21173 {
21174 PyThreadState* __tstate = wxPyBeginAllowThreads();
21175 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21176 wxPyEndAllowThreads(__tstate);
21177 if (PyErr_Occurred()) SWIG_fail;
21178 }
21179 resultobj = SWIG_From_int(static_cast< int >(result));
21180 return resultobj;
21181 fail:
21182 return NULL;
21183 }
21184
21185
21186 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21187 PyObject *resultobj = 0;
21188 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21189 int result;
21190 void *argp1 = 0 ;
21191 int res1 = 0 ;
21192 PyObject *swig_obj[1] ;
21193
21194 if (!args) SWIG_fail;
21195 swig_obj[0] = args;
21196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21197 if (!SWIG_IsOK(res1)) {
21198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21199 }
21200 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21201 {
21202 PyThreadState* __tstate = wxPyBeginAllowThreads();
21203 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21204 wxPyEndAllowThreads(__tstate);
21205 if (PyErr_Occurred()) SWIG_fail;
21206 }
21207 resultobj = SWIG_From_int(static_cast< int >(result));
21208 return resultobj;
21209 fail:
21210 return NULL;
21211 }
21212
21213
21214 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21215 PyObject *resultobj = 0;
21216 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21217 int result;
21218 void *argp1 = 0 ;
21219 int res1 = 0 ;
21220 PyObject *swig_obj[1] ;
21221
21222 if (!args) SWIG_fail;
21223 swig_obj[0] = args;
21224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21225 if (!SWIG_IsOK(res1)) {
21226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21227 }
21228 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21229 {
21230 PyThreadState* __tstate = wxPyBeginAllowThreads();
21231 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21232 wxPyEndAllowThreads(__tstate);
21233 if (PyErr_Occurred()) SWIG_fail;
21234 }
21235 resultobj = SWIG_From_int(static_cast< int >(result));
21236 return resultobj;
21237 fail:
21238 return NULL;
21239 }
21240
21241
21242 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21243 PyObject *resultobj = 0;
21244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21245 bool result;
21246 void *argp1 = 0 ;
21247 int res1 = 0 ;
21248 PyObject *swig_obj[1] ;
21249
21250 if (!args) SWIG_fail;
21251 swig_obj[0] = args;
21252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21253 if (!SWIG_IsOK(res1)) {
21254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21255 }
21256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21257 {
21258 PyThreadState* __tstate = wxPyBeginAllowThreads();
21259 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21260 wxPyEndAllowThreads(__tstate);
21261 if (PyErr_Occurred()) SWIG_fail;
21262 }
21263 {
21264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21265 }
21266 return resultobj;
21267 fail:
21268 return NULL;
21269 }
21270
21271
21272 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21273 PyObject *resultobj = 0;
21274 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21275 int arg2 ;
21276 void *argp1 = 0 ;
21277 int res1 = 0 ;
21278 int val2 ;
21279 int ecode2 = 0 ;
21280 PyObject *swig_obj[2] ;
21281
21282 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21284 if (!SWIG_IsOK(res1)) {
21285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21286 }
21287 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21288 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21289 if (!SWIG_IsOK(ecode2)) {
21290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21291 }
21292 arg2 = static_cast< int >(val2);
21293 if (arg1) (arg1)->m_x = arg2;
21294
21295 resultobj = SWIG_Py_Void();
21296 return resultobj;
21297 fail:
21298 return NULL;
21299 }
21300
21301
21302 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21303 PyObject *resultobj = 0;
21304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21305 int result;
21306 void *argp1 = 0 ;
21307 int res1 = 0 ;
21308 PyObject *swig_obj[1] ;
21309
21310 if (!args) SWIG_fail;
21311 swig_obj[0] = args;
21312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21313 if (!SWIG_IsOK(res1)) {
21314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21315 }
21316 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21317 result = (int) ((arg1)->m_x);
21318 resultobj = SWIG_From_int(static_cast< int >(result));
21319 return resultobj;
21320 fail:
21321 return NULL;
21322 }
21323
21324
21325 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21326 PyObject *resultobj = 0;
21327 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21328 int arg2 ;
21329 void *argp1 = 0 ;
21330 int res1 = 0 ;
21331 int val2 ;
21332 int ecode2 = 0 ;
21333 PyObject *swig_obj[2] ;
21334
21335 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21337 if (!SWIG_IsOK(res1)) {
21338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21339 }
21340 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21341 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21342 if (!SWIG_IsOK(ecode2)) {
21343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21344 }
21345 arg2 = static_cast< int >(val2);
21346 if (arg1) (arg1)->m_y = arg2;
21347
21348 resultobj = SWIG_Py_Void();
21349 return resultobj;
21350 fail:
21351 return NULL;
21352 }
21353
21354
21355 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21356 PyObject *resultobj = 0;
21357 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21358 int result;
21359 void *argp1 = 0 ;
21360 int res1 = 0 ;
21361 PyObject *swig_obj[1] ;
21362
21363 if (!args) SWIG_fail;
21364 swig_obj[0] = args;
21365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21366 if (!SWIG_IsOK(res1)) {
21367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21368 }
21369 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21370 result = (int) ((arg1)->m_y);
21371 resultobj = SWIG_From_int(static_cast< int >(result));
21372 return resultobj;
21373 fail:
21374 return NULL;
21375 }
21376
21377
21378 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21379 PyObject *resultobj = 0;
21380 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21381 bool arg2 ;
21382 void *argp1 = 0 ;
21383 int res1 = 0 ;
21384 bool val2 ;
21385 int ecode2 = 0 ;
21386 PyObject *swig_obj[2] ;
21387
21388 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21390 if (!SWIG_IsOK(res1)) {
21391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21392 }
21393 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21394 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21395 if (!SWIG_IsOK(ecode2)) {
21396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21397 }
21398 arg2 = static_cast< bool >(val2);
21399 if (arg1) (arg1)->m_leftDown = arg2;
21400
21401 resultobj = SWIG_Py_Void();
21402 return resultobj;
21403 fail:
21404 return NULL;
21405 }
21406
21407
21408 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21409 PyObject *resultobj = 0;
21410 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21411 bool result;
21412 void *argp1 = 0 ;
21413 int res1 = 0 ;
21414 PyObject *swig_obj[1] ;
21415
21416 if (!args) SWIG_fail;
21417 swig_obj[0] = args;
21418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21419 if (!SWIG_IsOK(res1)) {
21420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21421 }
21422 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21423 result = (bool) ((arg1)->m_leftDown);
21424 {
21425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21426 }
21427 return resultobj;
21428 fail:
21429 return NULL;
21430 }
21431
21432
21433 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21434 PyObject *resultobj = 0;
21435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21436 bool arg2 ;
21437 void *argp1 = 0 ;
21438 int res1 = 0 ;
21439 bool val2 ;
21440 int ecode2 = 0 ;
21441 PyObject *swig_obj[2] ;
21442
21443 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21445 if (!SWIG_IsOK(res1)) {
21446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21447 }
21448 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21449 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21450 if (!SWIG_IsOK(ecode2)) {
21451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21452 }
21453 arg2 = static_cast< bool >(val2);
21454 if (arg1) (arg1)->m_middleDown = arg2;
21455
21456 resultobj = SWIG_Py_Void();
21457 return resultobj;
21458 fail:
21459 return NULL;
21460 }
21461
21462
21463 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21464 PyObject *resultobj = 0;
21465 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21466 bool result;
21467 void *argp1 = 0 ;
21468 int res1 = 0 ;
21469 PyObject *swig_obj[1] ;
21470
21471 if (!args) SWIG_fail;
21472 swig_obj[0] = args;
21473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21474 if (!SWIG_IsOK(res1)) {
21475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21476 }
21477 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21478 result = (bool) ((arg1)->m_middleDown);
21479 {
21480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21481 }
21482 return resultobj;
21483 fail:
21484 return NULL;
21485 }
21486
21487
21488 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21489 PyObject *resultobj = 0;
21490 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21491 bool arg2 ;
21492 void *argp1 = 0 ;
21493 int res1 = 0 ;
21494 bool val2 ;
21495 int ecode2 = 0 ;
21496 PyObject *swig_obj[2] ;
21497
21498 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21500 if (!SWIG_IsOK(res1)) {
21501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21502 }
21503 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21504 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21505 if (!SWIG_IsOK(ecode2)) {
21506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21507 }
21508 arg2 = static_cast< bool >(val2);
21509 if (arg1) (arg1)->m_rightDown = arg2;
21510
21511 resultobj = SWIG_Py_Void();
21512 return resultobj;
21513 fail:
21514 return NULL;
21515 }
21516
21517
21518 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21519 PyObject *resultobj = 0;
21520 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21521 bool result;
21522 void *argp1 = 0 ;
21523 int res1 = 0 ;
21524 PyObject *swig_obj[1] ;
21525
21526 if (!args) SWIG_fail;
21527 swig_obj[0] = args;
21528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21529 if (!SWIG_IsOK(res1)) {
21530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21531 }
21532 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21533 result = (bool) ((arg1)->m_rightDown);
21534 {
21535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21536 }
21537 return resultobj;
21538 fail:
21539 return NULL;
21540 }
21541
21542
21543 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21544 PyObject *resultobj = 0;
21545 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21546 bool arg2 ;
21547 void *argp1 = 0 ;
21548 int res1 = 0 ;
21549 bool val2 ;
21550 int ecode2 = 0 ;
21551 PyObject *swig_obj[2] ;
21552
21553 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21555 if (!SWIG_IsOK(res1)) {
21556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21557 }
21558 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21559 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21560 if (!SWIG_IsOK(ecode2)) {
21561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21562 }
21563 arg2 = static_cast< bool >(val2);
21564 if (arg1) (arg1)->m_controlDown = arg2;
21565
21566 resultobj = SWIG_Py_Void();
21567 return resultobj;
21568 fail:
21569 return NULL;
21570 }
21571
21572
21573 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21574 PyObject *resultobj = 0;
21575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21576 bool result;
21577 void *argp1 = 0 ;
21578 int res1 = 0 ;
21579 PyObject *swig_obj[1] ;
21580
21581 if (!args) SWIG_fail;
21582 swig_obj[0] = args;
21583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21584 if (!SWIG_IsOK(res1)) {
21585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21586 }
21587 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21588 result = (bool) ((arg1)->m_controlDown);
21589 {
21590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21591 }
21592 return resultobj;
21593 fail:
21594 return NULL;
21595 }
21596
21597
21598 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21599 PyObject *resultobj = 0;
21600 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21601 bool arg2 ;
21602 void *argp1 = 0 ;
21603 int res1 = 0 ;
21604 bool val2 ;
21605 int ecode2 = 0 ;
21606 PyObject *swig_obj[2] ;
21607
21608 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21610 if (!SWIG_IsOK(res1)) {
21611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21612 }
21613 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21614 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21615 if (!SWIG_IsOK(ecode2)) {
21616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21617 }
21618 arg2 = static_cast< bool >(val2);
21619 if (arg1) (arg1)->m_shiftDown = arg2;
21620
21621 resultobj = SWIG_Py_Void();
21622 return resultobj;
21623 fail:
21624 return NULL;
21625 }
21626
21627
21628 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21629 PyObject *resultobj = 0;
21630 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21631 bool result;
21632 void *argp1 = 0 ;
21633 int res1 = 0 ;
21634 PyObject *swig_obj[1] ;
21635
21636 if (!args) SWIG_fail;
21637 swig_obj[0] = args;
21638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21639 if (!SWIG_IsOK(res1)) {
21640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21641 }
21642 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21643 result = (bool) ((arg1)->m_shiftDown);
21644 {
21645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21646 }
21647 return resultobj;
21648 fail:
21649 return NULL;
21650 }
21651
21652
21653 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21654 PyObject *resultobj = 0;
21655 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21656 bool arg2 ;
21657 void *argp1 = 0 ;
21658 int res1 = 0 ;
21659 bool val2 ;
21660 int ecode2 = 0 ;
21661 PyObject *swig_obj[2] ;
21662
21663 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21665 if (!SWIG_IsOK(res1)) {
21666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21667 }
21668 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21669 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21670 if (!SWIG_IsOK(ecode2)) {
21671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21672 }
21673 arg2 = static_cast< bool >(val2);
21674 if (arg1) (arg1)->m_altDown = arg2;
21675
21676 resultobj = SWIG_Py_Void();
21677 return resultobj;
21678 fail:
21679 return NULL;
21680 }
21681
21682
21683 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21684 PyObject *resultobj = 0;
21685 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21686 bool result;
21687 void *argp1 = 0 ;
21688 int res1 = 0 ;
21689 PyObject *swig_obj[1] ;
21690
21691 if (!args) SWIG_fail;
21692 swig_obj[0] = args;
21693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21694 if (!SWIG_IsOK(res1)) {
21695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21696 }
21697 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21698 result = (bool) ((arg1)->m_altDown);
21699 {
21700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21701 }
21702 return resultobj;
21703 fail:
21704 return NULL;
21705 }
21706
21707
21708 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21709 PyObject *resultobj = 0;
21710 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21711 bool arg2 ;
21712 void *argp1 = 0 ;
21713 int res1 = 0 ;
21714 bool val2 ;
21715 int ecode2 = 0 ;
21716 PyObject *swig_obj[2] ;
21717
21718 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21720 if (!SWIG_IsOK(res1)) {
21721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21722 }
21723 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21724 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21725 if (!SWIG_IsOK(ecode2)) {
21726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21727 }
21728 arg2 = static_cast< bool >(val2);
21729 if (arg1) (arg1)->m_metaDown = arg2;
21730
21731 resultobj = SWIG_Py_Void();
21732 return resultobj;
21733 fail:
21734 return NULL;
21735 }
21736
21737
21738 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21739 PyObject *resultobj = 0;
21740 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21741 bool result;
21742 void *argp1 = 0 ;
21743 int res1 = 0 ;
21744 PyObject *swig_obj[1] ;
21745
21746 if (!args) SWIG_fail;
21747 swig_obj[0] = args;
21748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21749 if (!SWIG_IsOK(res1)) {
21750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21751 }
21752 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21753 result = (bool) ((arg1)->m_metaDown);
21754 {
21755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21756 }
21757 return resultobj;
21758 fail:
21759 return NULL;
21760 }
21761
21762
21763 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21764 PyObject *resultobj = 0;
21765 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21766 int arg2 ;
21767 void *argp1 = 0 ;
21768 int res1 = 0 ;
21769 int val2 ;
21770 int ecode2 = 0 ;
21771 PyObject *swig_obj[2] ;
21772
21773 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21775 if (!SWIG_IsOK(res1)) {
21776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21777 }
21778 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21779 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21780 if (!SWIG_IsOK(ecode2)) {
21781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21782 }
21783 arg2 = static_cast< int >(val2);
21784 if (arg1) (arg1)->m_wheelRotation = arg2;
21785
21786 resultobj = SWIG_Py_Void();
21787 return resultobj;
21788 fail:
21789 return NULL;
21790 }
21791
21792
21793 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21794 PyObject *resultobj = 0;
21795 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21796 int result;
21797 void *argp1 = 0 ;
21798 int res1 = 0 ;
21799 PyObject *swig_obj[1] ;
21800
21801 if (!args) SWIG_fail;
21802 swig_obj[0] = args;
21803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21804 if (!SWIG_IsOK(res1)) {
21805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21806 }
21807 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21808 result = (int) ((arg1)->m_wheelRotation);
21809 resultobj = SWIG_From_int(static_cast< int >(result));
21810 return resultobj;
21811 fail:
21812 return NULL;
21813 }
21814
21815
21816 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21817 PyObject *resultobj = 0;
21818 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21819 int arg2 ;
21820 void *argp1 = 0 ;
21821 int res1 = 0 ;
21822 int val2 ;
21823 int ecode2 = 0 ;
21824 PyObject *swig_obj[2] ;
21825
21826 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21828 if (!SWIG_IsOK(res1)) {
21829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21830 }
21831 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21832 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21833 if (!SWIG_IsOK(ecode2)) {
21834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21835 }
21836 arg2 = static_cast< int >(val2);
21837 if (arg1) (arg1)->m_wheelDelta = arg2;
21838
21839 resultobj = SWIG_Py_Void();
21840 return resultobj;
21841 fail:
21842 return NULL;
21843 }
21844
21845
21846 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21847 PyObject *resultobj = 0;
21848 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21849 int result;
21850 void *argp1 = 0 ;
21851 int res1 = 0 ;
21852 PyObject *swig_obj[1] ;
21853
21854 if (!args) SWIG_fail;
21855 swig_obj[0] = args;
21856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21857 if (!SWIG_IsOK(res1)) {
21858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21859 }
21860 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21861 result = (int) ((arg1)->m_wheelDelta);
21862 resultobj = SWIG_From_int(static_cast< int >(result));
21863 return resultobj;
21864 fail:
21865 return NULL;
21866 }
21867
21868
21869 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21870 PyObject *resultobj = 0;
21871 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21872 int arg2 ;
21873 void *argp1 = 0 ;
21874 int res1 = 0 ;
21875 int val2 ;
21876 int ecode2 = 0 ;
21877 PyObject *swig_obj[2] ;
21878
21879 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21881 if (!SWIG_IsOK(res1)) {
21882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21883 }
21884 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21885 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21886 if (!SWIG_IsOK(ecode2)) {
21887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21888 }
21889 arg2 = static_cast< int >(val2);
21890 if (arg1) (arg1)->m_linesPerAction = arg2;
21891
21892 resultobj = SWIG_Py_Void();
21893 return resultobj;
21894 fail:
21895 return NULL;
21896 }
21897
21898
21899 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21900 PyObject *resultobj = 0;
21901 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21902 int result;
21903 void *argp1 = 0 ;
21904 int res1 = 0 ;
21905 PyObject *swig_obj[1] ;
21906
21907 if (!args) SWIG_fail;
21908 swig_obj[0] = args;
21909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21910 if (!SWIG_IsOK(res1)) {
21911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21912 }
21913 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21914 result = (int) ((arg1)->m_linesPerAction);
21915 resultobj = SWIG_From_int(static_cast< int >(result));
21916 return resultobj;
21917 fail:
21918 return NULL;
21919 }
21920
21921
21922 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21923 PyObject *obj;
21924 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21925 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21926 return SWIG_Py_Void();
21927 }
21928
21929 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21930 return SWIG_Python_InitShadowInstance(args);
21931 }
21932
21933 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21934 PyObject *resultobj = 0;
21935 int arg1 = (int) 0 ;
21936 int arg2 = (int) 0 ;
21937 wxSetCursorEvent *result = 0 ;
21938 int val1 ;
21939 int ecode1 = 0 ;
21940 int val2 ;
21941 int ecode2 = 0 ;
21942 PyObject * obj0 = 0 ;
21943 PyObject * obj1 = 0 ;
21944 char * kwnames[] = {
21945 (char *) "x",(char *) "y", NULL
21946 };
21947
21948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21949 if (obj0) {
21950 ecode1 = SWIG_AsVal_int(obj0, &val1);
21951 if (!SWIG_IsOK(ecode1)) {
21952 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21953 }
21954 arg1 = static_cast< int >(val1);
21955 }
21956 if (obj1) {
21957 ecode2 = SWIG_AsVal_int(obj1, &val2);
21958 if (!SWIG_IsOK(ecode2)) {
21959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21960 }
21961 arg2 = static_cast< int >(val2);
21962 }
21963 {
21964 PyThreadState* __tstate = wxPyBeginAllowThreads();
21965 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21966 wxPyEndAllowThreads(__tstate);
21967 if (PyErr_Occurred()) SWIG_fail;
21968 }
21969 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21970 return resultobj;
21971 fail:
21972 return NULL;
21973 }
21974
21975
21976 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21977 PyObject *resultobj = 0;
21978 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21979 int result;
21980 void *argp1 = 0 ;
21981 int res1 = 0 ;
21982 PyObject *swig_obj[1] ;
21983
21984 if (!args) SWIG_fail;
21985 swig_obj[0] = args;
21986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21987 if (!SWIG_IsOK(res1)) {
21988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21989 }
21990 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21991 {
21992 PyThreadState* __tstate = wxPyBeginAllowThreads();
21993 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21994 wxPyEndAllowThreads(__tstate);
21995 if (PyErr_Occurred()) SWIG_fail;
21996 }
21997 resultobj = SWIG_From_int(static_cast< int >(result));
21998 return resultobj;
21999 fail:
22000 return NULL;
22001 }
22002
22003
22004 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22005 PyObject *resultobj = 0;
22006 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22007 int result;
22008 void *argp1 = 0 ;
22009 int res1 = 0 ;
22010 PyObject *swig_obj[1] ;
22011
22012 if (!args) SWIG_fail;
22013 swig_obj[0] = args;
22014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22015 if (!SWIG_IsOK(res1)) {
22016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22017 }
22018 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22019 {
22020 PyThreadState* __tstate = wxPyBeginAllowThreads();
22021 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22022 wxPyEndAllowThreads(__tstate);
22023 if (PyErr_Occurred()) SWIG_fail;
22024 }
22025 resultobj = SWIG_From_int(static_cast< int >(result));
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22033 PyObject *resultobj = 0;
22034 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22035 wxCursor *arg2 = 0 ;
22036 void *argp1 = 0 ;
22037 int res1 = 0 ;
22038 void *argp2 = 0 ;
22039 int res2 = 0 ;
22040 PyObject * obj0 = 0 ;
22041 PyObject * obj1 = 0 ;
22042 char * kwnames[] = {
22043 (char *) "self",(char *) "cursor", NULL
22044 };
22045
22046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22048 if (!SWIG_IsOK(res1)) {
22049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22050 }
22051 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22052 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22053 if (!SWIG_IsOK(res2)) {
22054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22055 }
22056 if (!argp2) {
22057 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22058 }
22059 arg2 = reinterpret_cast< wxCursor * >(argp2);
22060 {
22061 PyThreadState* __tstate = wxPyBeginAllowThreads();
22062 (arg1)->SetCursor((wxCursor const &)*arg2);
22063 wxPyEndAllowThreads(__tstate);
22064 if (PyErr_Occurred()) SWIG_fail;
22065 }
22066 resultobj = SWIG_Py_Void();
22067 return resultobj;
22068 fail:
22069 return NULL;
22070 }
22071
22072
22073 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22074 PyObject *resultobj = 0;
22075 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22076 wxCursor *result = 0 ;
22077 void *argp1 = 0 ;
22078 int res1 = 0 ;
22079 PyObject *swig_obj[1] ;
22080
22081 if (!args) SWIG_fail;
22082 swig_obj[0] = args;
22083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22084 if (!SWIG_IsOK(res1)) {
22085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22086 }
22087 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22088 {
22089 PyThreadState* __tstate = wxPyBeginAllowThreads();
22090 {
22091 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22092 result = (wxCursor *) &_result_ref;
22093 }
22094 wxPyEndAllowThreads(__tstate);
22095 if (PyErr_Occurred()) SWIG_fail;
22096 }
22097 {
22098 wxCursor* resultptr = new wxCursor(*result);
22099 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22100 }
22101 return resultobj;
22102 fail:
22103 return NULL;
22104 }
22105
22106
22107 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22108 PyObject *resultobj = 0;
22109 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22110 bool result;
22111 void *argp1 = 0 ;
22112 int res1 = 0 ;
22113 PyObject *swig_obj[1] ;
22114
22115 if (!args) SWIG_fail;
22116 swig_obj[0] = args;
22117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22118 if (!SWIG_IsOK(res1)) {
22119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22120 }
22121 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22122 {
22123 PyThreadState* __tstate = wxPyBeginAllowThreads();
22124 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22125 wxPyEndAllowThreads(__tstate);
22126 if (PyErr_Occurred()) SWIG_fail;
22127 }
22128 {
22129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22130 }
22131 return resultobj;
22132 fail:
22133 return NULL;
22134 }
22135
22136
22137 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22138 PyObject *obj;
22139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22140 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22141 return SWIG_Py_Void();
22142 }
22143
22144 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22145 return SWIG_Python_InitShadowInstance(args);
22146 }
22147
22148 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22149 PyObject *resultobj = 0;
22150 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22151 wxKeyEvent *result = 0 ;
22152 int val1 ;
22153 int ecode1 = 0 ;
22154 PyObject * obj0 = 0 ;
22155 char * kwnames[] = {
22156 (char *) "eventType", NULL
22157 };
22158
22159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22160 if (obj0) {
22161 ecode1 = SWIG_AsVal_int(obj0, &val1);
22162 if (!SWIG_IsOK(ecode1)) {
22163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22164 }
22165 arg1 = static_cast< wxEventType >(val1);
22166 }
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22170 wxPyEndAllowThreads(__tstate);
22171 if (PyErr_Occurred()) SWIG_fail;
22172 }
22173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22174 return resultobj;
22175 fail:
22176 return NULL;
22177 }
22178
22179
22180 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22181 PyObject *resultobj = 0;
22182 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22183 int result;
22184 void *argp1 = 0 ;
22185 int res1 = 0 ;
22186 PyObject *swig_obj[1] ;
22187
22188 if (!args) SWIG_fail;
22189 swig_obj[0] = args;
22190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22191 if (!SWIG_IsOK(res1)) {
22192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22193 }
22194 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22195 {
22196 PyThreadState* __tstate = wxPyBeginAllowThreads();
22197 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22198 wxPyEndAllowThreads(__tstate);
22199 if (PyErr_Occurred()) SWIG_fail;
22200 }
22201 resultobj = SWIG_From_int(static_cast< int >(result));
22202 return resultobj;
22203 fail:
22204 return NULL;
22205 }
22206
22207
22208 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22209 PyObject *resultobj = 0;
22210 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22211 bool result;
22212 void *argp1 = 0 ;
22213 int res1 = 0 ;
22214 PyObject *swig_obj[1] ;
22215
22216 if (!args) SWIG_fail;
22217 swig_obj[0] = args;
22218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22219 if (!SWIG_IsOK(res1)) {
22220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22221 }
22222 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22223 {
22224 PyThreadState* __tstate = wxPyBeginAllowThreads();
22225 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 {
22230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22231 }
22232 return resultobj;
22233 fail:
22234 return NULL;
22235 }
22236
22237
22238 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22239 PyObject *resultobj = 0;
22240 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22241 bool result;
22242 void *argp1 = 0 ;
22243 int res1 = 0 ;
22244 PyObject *swig_obj[1] ;
22245
22246 if (!args) SWIG_fail;
22247 swig_obj[0] = args;
22248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22249 if (!SWIG_IsOK(res1)) {
22250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22251 }
22252 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22253 {
22254 PyThreadState* __tstate = wxPyBeginAllowThreads();
22255 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22256 wxPyEndAllowThreads(__tstate);
22257 if (PyErr_Occurred()) SWIG_fail;
22258 }
22259 {
22260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22261 }
22262 return resultobj;
22263 fail:
22264 return NULL;
22265 }
22266
22267
22268 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22269 PyObject *resultobj = 0;
22270 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22271 bool result;
22272 void *argp1 = 0 ;
22273 int res1 = 0 ;
22274 PyObject *swig_obj[1] ;
22275
22276 if (!args) SWIG_fail;
22277 swig_obj[0] = args;
22278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22279 if (!SWIG_IsOK(res1)) {
22280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22281 }
22282 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22283 {
22284 PyThreadState* __tstate = wxPyBeginAllowThreads();
22285 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22286 wxPyEndAllowThreads(__tstate);
22287 if (PyErr_Occurred()) SWIG_fail;
22288 }
22289 {
22290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22291 }
22292 return resultobj;
22293 fail:
22294 return NULL;
22295 }
22296
22297
22298 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22299 PyObject *resultobj = 0;
22300 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22301 bool result;
22302 void *argp1 = 0 ;
22303 int res1 = 0 ;
22304 PyObject *swig_obj[1] ;
22305
22306 if (!args) SWIG_fail;
22307 swig_obj[0] = args;
22308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22309 if (!SWIG_IsOK(res1)) {
22310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22311 }
22312 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22313 {
22314 PyThreadState* __tstate = wxPyBeginAllowThreads();
22315 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22316 wxPyEndAllowThreads(__tstate);
22317 if (PyErr_Occurred()) SWIG_fail;
22318 }
22319 {
22320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22321 }
22322 return resultobj;
22323 fail:
22324 return NULL;
22325 }
22326
22327
22328 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22329 PyObject *resultobj = 0;
22330 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22331 bool result;
22332 void *argp1 = 0 ;
22333 int res1 = 0 ;
22334 PyObject *swig_obj[1] ;
22335
22336 if (!args) SWIG_fail;
22337 swig_obj[0] = args;
22338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22339 if (!SWIG_IsOK(res1)) {
22340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22341 }
22342 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22343 {
22344 PyThreadState* __tstate = wxPyBeginAllowThreads();
22345 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22346 wxPyEndAllowThreads(__tstate);
22347 if (PyErr_Occurred()) SWIG_fail;
22348 }
22349 {
22350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22351 }
22352 return resultobj;
22353 fail:
22354 return NULL;
22355 }
22356
22357
22358 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22359 PyObject *resultobj = 0;
22360 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22361 bool result;
22362 void *argp1 = 0 ;
22363 int res1 = 0 ;
22364 PyObject *swig_obj[1] ;
22365
22366 if (!args) SWIG_fail;
22367 swig_obj[0] = args;
22368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22369 if (!SWIG_IsOK(res1)) {
22370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22371 }
22372 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22373 {
22374 PyThreadState* __tstate = wxPyBeginAllowThreads();
22375 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22376 wxPyEndAllowThreads(__tstate);
22377 if (PyErr_Occurred()) SWIG_fail;
22378 }
22379 {
22380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22381 }
22382 return resultobj;
22383 fail:
22384 return NULL;
22385 }
22386
22387
22388 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22389 PyObject *resultobj = 0;
22390 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22391 int result;
22392 void *argp1 = 0 ;
22393 int res1 = 0 ;
22394 PyObject *swig_obj[1] ;
22395
22396 if (!args) SWIG_fail;
22397 swig_obj[0] = args;
22398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22399 if (!SWIG_IsOK(res1)) {
22400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22401 }
22402 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22403 {
22404 PyThreadState* __tstate = wxPyBeginAllowThreads();
22405 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22406 wxPyEndAllowThreads(__tstate);
22407 if (PyErr_Occurred()) SWIG_fail;
22408 }
22409 resultobj = SWIG_From_int(static_cast< int >(result));
22410 return resultobj;
22411 fail:
22412 return NULL;
22413 }
22414
22415
22416 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22417 PyObject *resultobj = 0;
22418 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22419 int result;
22420 void *argp1 = 0 ;
22421 int res1 = 0 ;
22422 PyObject *swig_obj[1] ;
22423
22424 if (!args) SWIG_fail;
22425 swig_obj[0] = args;
22426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22427 if (!SWIG_IsOK(res1)) {
22428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22429 }
22430 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22431 {
22432 PyThreadState* __tstate = wxPyBeginAllowThreads();
22433 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22434 wxPyEndAllowThreads(__tstate);
22435 if (PyErr_Occurred()) SWIG_fail;
22436 }
22437 resultobj = SWIG_From_int(static_cast< int >(result));
22438 return resultobj;
22439 fail:
22440 return NULL;
22441 }
22442
22443
22444 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22445 PyObject *resultobj = 0;
22446 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22447 int arg2 ;
22448 void *argp1 = 0 ;
22449 int res1 = 0 ;
22450 int val2 ;
22451 int ecode2 = 0 ;
22452 PyObject * obj0 = 0 ;
22453 PyObject * obj1 = 0 ;
22454 char * kwnames[] = {
22455 (char *) "self",(char *) "uniChar", NULL
22456 };
22457
22458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22460 if (!SWIG_IsOK(res1)) {
22461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22462 }
22463 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22464 ecode2 = SWIG_AsVal_int(obj1, &val2);
22465 if (!SWIG_IsOK(ecode2)) {
22466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22467 }
22468 arg2 = static_cast< int >(val2);
22469 {
22470 PyThreadState* __tstate = wxPyBeginAllowThreads();
22471 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22472 wxPyEndAllowThreads(__tstate);
22473 if (PyErr_Occurred()) SWIG_fail;
22474 }
22475 resultobj = SWIG_Py_Void();
22476 return resultobj;
22477 fail:
22478 return NULL;
22479 }
22480
22481
22482 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22483 PyObject *resultobj = 0;
22484 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22485 unsigned int result;
22486 void *argp1 = 0 ;
22487 int res1 = 0 ;
22488 PyObject *swig_obj[1] ;
22489
22490 if (!args) SWIG_fail;
22491 swig_obj[0] = args;
22492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22493 if (!SWIG_IsOK(res1)) {
22494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22495 }
22496 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22497 {
22498 PyThreadState* __tstate = wxPyBeginAllowThreads();
22499 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22500 wxPyEndAllowThreads(__tstate);
22501 if (PyErr_Occurred()) SWIG_fail;
22502 }
22503 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22504 return resultobj;
22505 fail:
22506 return NULL;
22507 }
22508
22509
22510 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22511 PyObject *resultobj = 0;
22512 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22513 unsigned int result;
22514 void *argp1 = 0 ;
22515 int res1 = 0 ;
22516 PyObject *swig_obj[1] ;
22517
22518 if (!args) SWIG_fail;
22519 swig_obj[0] = args;
22520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22521 if (!SWIG_IsOK(res1)) {
22522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22523 }
22524 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22525 {
22526 PyThreadState* __tstate = wxPyBeginAllowThreads();
22527 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22528 wxPyEndAllowThreads(__tstate);
22529 if (PyErr_Occurred()) SWIG_fail;
22530 }
22531 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22532 return resultobj;
22533 fail:
22534 return NULL;
22535 }
22536
22537
22538 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22539 PyObject *resultobj = 0;
22540 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22541 wxPoint result;
22542 void *argp1 = 0 ;
22543 int res1 = 0 ;
22544 PyObject *swig_obj[1] ;
22545
22546 if (!args) SWIG_fail;
22547 swig_obj[0] = args;
22548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22549 if (!SWIG_IsOK(res1)) {
22550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22551 }
22552 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22553 {
22554 PyThreadState* __tstate = wxPyBeginAllowThreads();
22555 result = (arg1)->GetPosition();
22556 wxPyEndAllowThreads(__tstate);
22557 if (PyErr_Occurred()) SWIG_fail;
22558 }
22559 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22560 return resultobj;
22561 fail:
22562 return NULL;
22563 }
22564
22565
22566 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22567 PyObject *resultobj = 0;
22568 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22569 long *arg2 = (long *) 0 ;
22570 long *arg3 = (long *) 0 ;
22571 void *argp1 = 0 ;
22572 int res1 = 0 ;
22573 long temp2 ;
22574 int res2 = SWIG_TMPOBJ ;
22575 long temp3 ;
22576 int res3 = SWIG_TMPOBJ ;
22577 PyObject *swig_obj[1] ;
22578
22579 arg2 = &temp2;
22580 arg3 = &temp3;
22581 if (!args) SWIG_fail;
22582 swig_obj[0] = args;
22583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22584 if (!SWIG_IsOK(res1)) {
22585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22586 }
22587 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22588 {
22589 PyThreadState* __tstate = wxPyBeginAllowThreads();
22590 (arg1)->GetPosition(arg2,arg3);
22591 wxPyEndAllowThreads(__tstate);
22592 if (PyErr_Occurred()) SWIG_fail;
22593 }
22594 resultobj = SWIG_Py_Void();
22595 if (SWIG_IsTmpObj(res2)) {
22596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22597 } else {
22598 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22599 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22600 }
22601 if (SWIG_IsTmpObj(res3)) {
22602 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22603 } else {
22604 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22605 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22606 }
22607 return resultobj;
22608 fail:
22609 return NULL;
22610 }
22611
22612
22613 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22614 PyObject *resultobj = 0;
22615 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22616 int result;
22617 void *argp1 = 0 ;
22618 int res1 = 0 ;
22619 PyObject *swig_obj[1] ;
22620
22621 if (!args) SWIG_fail;
22622 swig_obj[0] = args;
22623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22624 if (!SWIG_IsOK(res1)) {
22625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22626 }
22627 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22628 {
22629 PyThreadState* __tstate = wxPyBeginAllowThreads();
22630 result = (int)((wxKeyEvent const *)arg1)->GetX();
22631 wxPyEndAllowThreads(__tstate);
22632 if (PyErr_Occurred()) SWIG_fail;
22633 }
22634 resultobj = SWIG_From_int(static_cast< int >(result));
22635 return resultobj;
22636 fail:
22637 return NULL;
22638 }
22639
22640
22641 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22642 PyObject *resultobj = 0;
22643 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22644 int result;
22645 void *argp1 = 0 ;
22646 int res1 = 0 ;
22647 PyObject *swig_obj[1] ;
22648
22649 if (!args) SWIG_fail;
22650 swig_obj[0] = args;
22651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22652 if (!SWIG_IsOK(res1)) {
22653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22654 }
22655 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22656 {
22657 PyThreadState* __tstate = wxPyBeginAllowThreads();
22658 result = (int)((wxKeyEvent const *)arg1)->GetY();
22659 wxPyEndAllowThreads(__tstate);
22660 if (PyErr_Occurred()) SWIG_fail;
22661 }
22662 resultobj = SWIG_From_int(static_cast< int >(result));
22663 return resultobj;
22664 fail:
22665 return NULL;
22666 }
22667
22668
22669 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22670 PyObject *resultobj = 0;
22671 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22672 int arg2 ;
22673 void *argp1 = 0 ;
22674 int res1 = 0 ;
22675 int val2 ;
22676 int ecode2 = 0 ;
22677 PyObject *swig_obj[2] ;
22678
22679 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22681 if (!SWIG_IsOK(res1)) {
22682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22683 }
22684 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22685 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22686 if (!SWIG_IsOK(ecode2)) {
22687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22688 }
22689 arg2 = static_cast< int >(val2);
22690 if (arg1) (arg1)->m_x = arg2;
22691
22692 resultobj = SWIG_Py_Void();
22693 return resultobj;
22694 fail:
22695 return NULL;
22696 }
22697
22698
22699 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22700 PyObject *resultobj = 0;
22701 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22702 int result;
22703 void *argp1 = 0 ;
22704 int res1 = 0 ;
22705 PyObject *swig_obj[1] ;
22706
22707 if (!args) SWIG_fail;
22708 swig_obj[0] = args;
22709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22710 if (!SWIG_IsOK(res1)) {
22711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22712 }
22713 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22714 result = (int) ((arg1)->m_x);
22715 resultobj = SWIG_From_int(static_cast< int >(result));
22716 return resultobj;
22717 fail:
22718 return NULL;
22719 }
22720
22721
22722 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22723 PyObject *resultobj = 0;
22724 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22725 int arg2 ;
22726 void *argp1 = 0 ;
22727 int res1 = 0 ;
22728 int val2 ;
22729 int ecode2 = 0 ;
22730 PyObject *swig_obj[2] ;
22731
22732 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22734 if (!SWIG_IsOK(res1)) {
22735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22736 }
22737 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22738 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22739 if (!SWIG_IsOK(ecode2)) {
22740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22741 }
22742 arg2 = static_cast< int >(val2);
22743 if (arg1) (arg1)->m_y = arg2;
22744
22745 resultobj = SWIG_Py_Void();
22746 return resultobj;
22747 fail:
22748 return NULL;
22749 }
22750
22751
22752 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22753 PyObject *resultobj = 0;
22754 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22755 int result;
22756 void *argp1 = 0 ;
22757 int res1 = 0 ;
22758 PyObject *swig_obj[1] ;
22759
22760 if (!args) SWIG_fail;
22761 swig_obj[0] = args;
22762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22763 if (!SWIG_IsOK(res1)) {
22764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22765 }
22766 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22767 result = (int) ((arg1)->m_y);
22768 resultobj = SWIG_From_int(static_cast< int >(result));
22769 return resultobj;
22770 fail:
22771 return NULL;
22772 }
22773
22774
22775 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22776 PyObject *resultobj = 0;
22777 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22778 long arg2 ;
22779 void *argp1 = 0 ;
22780 int res1 = 0 ;
22781 long val2 ;
22782 int ecode2 = 0 ;
22783 PyObject *swig_obj[2] ;
22784
22785 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22787 if (!SWIG_IsOK(res1)) {
22788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22789 }
22790 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22791 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22792 if (!SWIG_IsOK(ecode2)) {
22793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22794 }
22795 arg2 = static_cast< long >(val2);
22796 if (arg1) (arg1)->m_keyCode = arg2;
22797
22798 resultobj = SWIG_Py_Void();
22799 return resultobj;
22800 fail:
22801 return NULL;
22802 }
22803
22804
22805 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22806 PyObject *resultobj = 0;
22807 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22808 long result;
22809 void *argp1 = 0 ;
22810 int res1 = 0 ;
22811 PyObject *swig_obj[1] ;
22812
22813 if (!args) SWIG_fail;
22814 swig_obj[0] = args;
22815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22816 if (!SWIG_IsOK(res1)) {
22817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22818 }
22819 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22820 result = (long) ((arg1)->m_keyCode);
22821 resultobj = SWIG_From_long(static_cast< long >(result));
22822 return resultobj;
22823 fail:
22824 return NULL;
22825 }
22826
22827
22828 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22829 PyObject *resultobj = 0;
22830 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22831 bool arg2 ;
22832 void *argp1 = 0 ;
22833 int res1 = 0 ;
22834 bool val2 ;
22835 int ecode2 = 0 ;
22836 PyObject *swig_obj[2] ;
22837
22838 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22840 if (!SWIG_IsOK(res1)) {
22841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22842 }
22843 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22844 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22845 if (!SWIG_IsOK(ecode2)) {
22846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22847 }
22848 arg2 = static_cast< bool >(val2);
22849 if (arg1) (arg1)->m_controlDown = arg2;
22850
22851 resultobj = SWIG_Py_Void();
22852 return resultobj;
22853 fail:
22854 return NULL;
22855 }
22856
22857
22858 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22859 PyObject *resultobj = 0;
22860 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22861 bool result;
22862 void *argp1 = 0 ;
22863 int res1 = 0 ;
22864 PyObject *swig_obj[1] ;
22865
22866 if (!args) SWIG_fail;
22867 swig_obj[0] = args;
22868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22869 if (!SWIG_IsOK(res1)) {
22870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22871 }
22872 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22873 result = (bool) ((arg1)->m_controlDown);
22874 {
22875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22876 }
22877 return resultobj;
22878 fail:
22879 return NULL;
22880 }
22881
22882
22883 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22884 PyObject *resultobj = 0;
22885 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22886 bool arg2 ;
22887 void *argp1 = 0 ;
22888 int res1 = 0 ;
22889 bool val2 ;
22890 int ecode2 = 0 ;
22891 PyObject *swig_obj[2] ;
22892
22893 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22895 if (!SWIG_IsOK(res1)) {
22896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22897 }
22898 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22899 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22900 if (!SWIG_IsOK(ecode2)) {
22901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22902 }
22903 arg2 = static_cast< bool >(val2);
22904 if (arg1) (arg1)->m_shiftDown = arg2;
22905
22906 resultobj = SWIG_Py_Void();
22907 return resultobj;
22908 fail:
22909 return NULL;
22910 }
22911
22912
22913 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22914 PyObject *resultobj = 0;
22915 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22916 bool result;
22917 void *argp1 = 0 ;
22918 int res1 = 0 ;
22919 PyObject *swig_obj[1] ;
22920
22921 if (!args) SWIG_fail;
22922 swig_obj[0] = args;
22923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22924 if (!SWIG_IsOK(res1)) {
22925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22926 }
22927 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22928 result = (bool) ((arg1)->m_shiftDown);
22929 {
22930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22931 }
22932 return resultobj;
22933 fail:
22934 return NULL;
22935 }
22936
22937
22938 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22939 PyObject *resultobj = 0;
22940 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22941 bool arg2 ;
22942 void *argp1 = 0 ;
22943 int res1 = 0 ;
22944 bool val2 ;
22945 int ecode2 = 0 ;
22946 PyObject *swig_obj[2] ;
22947
22948 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22950 if (!SWIG_IsOK(res1)) {
22951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22952 }
22953 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22954 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22955 if (!SWIG_IsOK(ecode2)) {
22956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22957 }
22958 arg2 = static_cast< bool >(val2);
22959 if (arg1) (arg1)->m_altDown = arg2;
22960
22961 resultobj = SWIG_Py_Void();
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22969 PyObject *resultobj = 0;
22970 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22971 bool result;
22972 void *argp1 = 0 ;
22973 int res1 = 0 ;
22974 PyObject *swig_obj[1] ;
22975
22976 if (!args) SWIG_fail;
22977 swig_obj[0] = args;
22978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22979 if (!SWIG_IsOK(res1)) {
22980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22981 }
22982 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22983 result = (bool) ((arg1)->m_altDown);
22984 {
22985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22986 }
22987 return resultobj;
22988 fail:
22989 return NULL;
22990 }
22991
22992
22993 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22994 PyObject *resultobj = 0;
22995 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22996 bool arg2 ;
22997 void *argp1 = 0 ;
22998 int res1 = 0 ;
22999 bool val2 ;
23000 int ecode2 = 0 ;
23001 PyObject *swig_obj[2] ;
23002
23003 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23005 if (!SWIG_IsOK(res1)) {
23006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23007 }
23008 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23009 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23010 if (!SWIG_IsOK(ecode2)) {
23011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23012 }
23013 arg2 = static_cast< bool >(val2);
23014 if (arg1) (arg1)->m_metaDown = arg2;
23015
23016 resultobj = SWIG_Py_Void();
23017 return resultobj;
23018 fail:
23019 return NULL;
23020 }
23021
23022
23023 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23024 PyObject *resultobj = 0;
23025 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23026 bool result;
23027 void *argp1 = 0 ;
23028 int res1 = 0 ;
23029 PyObject *swig_obj[1] ;
23030
23031 if (!args) SWIG_fail;
23032 swig_obj[0] = args;
23033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23034 if (!SWIG_IsOK(res1)) {
23035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23036 }
23037 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23038 result = (bool) ((arg1)->m_metaDown);
23039 {
23040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23041 }
23042 return resultobj;
23043 fail:
23044 return NULL;
23045 }
23046
23047
23048 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23049 PyObject *resultobj = 0;
23050 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23051 bool arg2 ;
23052 void *argp1 = 0 ;
23053 int res1 = 0 ;
23054 bool val2 ;
23055 int ecode2 = 0 ;
23056 PyObject *swig_obj[2] ;
23057
23058 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23060 if (!SWIG_IsOK(res1)) {
23061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23062 }
23063 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23064 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23065 if (!SWIG_IsOK(ecode2)) {
23066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23067 }
23068 arg2 = static_cast< bool >(val2);
23069 if (arg1) (arg1)->m_scanCode = arg2;
23070
23071 resultobj = SWIG_Py_Void();
23072 return resultobj;
23073 fail:
23074 return NULL;
23075 }
23076
23077
23078 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23079 PyObject *resultobj = 0;
23080 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23081 bool result;
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_wxKeyEvent, 0 | 0 );
23089 if (!SWIG_IsOK(res1)) {
23090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23091 }
23092 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23093 result = (bool) ((arg1)->m_scanCode);
23094 {
23095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23096 }
23097 return resultobj;
23098 fail:
23099 return NULL;
23100 }
23101
23102
23103 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23104 PyObject *resultobj = 0;
23105 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23106 unsigned int arg2 ;
23107 void *argp1 = 0 ;
23108 int res1 = 0 ;
23109 unsigned int val2 ;
23110 int ecode2 = 0 ;
23111 PyObject *swig_obj[2] ;
23112
23113 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23115 if (!SWIG_IsOK(res1)) {
23116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23117 }
23118 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23119 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23120 if (!SWIG_IsOK(ecode2)) {
23121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23122 }
23123 arg2 = static_cast< unsigned int >(val2);
23124 if (arg1) (arg1)->m_rawCode = arg2;
23125
23126 resultobj = SWIG_Py_Void();
23127 return resultobj;
23128 fail:
23129 return NULL;
23130 }
23131
23132
23133 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23134 PyObject *resultobj = 0;
23135 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23136 unsigned int result;
23137 void *argp1 = 0 ;
23138 int res1 = 0 ;
23139 PyObject *swig_obj[1] ;
23140
23141 if (!args) SWIG_fail;
23142 swig_obj[0] = args;
23143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23144 if (!SWIG_IsOK(res1)) {
23145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23146 }
23147 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23148 result = (unsigned int) ((arg1)->m_rawCode);
23149 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23150 return resultobj;
23151 fail:
23152 return NULL;
23153 }
23154
23155
23156 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23157 PyObject *resultobj = 0;
23158 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23159 unsigned int arg2 ;
23160 void *argp1 = 0 ;
23161 int res1 = 0 ;
23162 unsigned int val2 ;
23163 int ecode2 = 0 ;
23164 PyObject *swig_obj[2] ;
23165
23166 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23168 if (!SWIG_IsOK(res1)) {
23169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23170 }
23171 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23172 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23173 if (!SWIG_IsOK(ecode2)) {
23174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23175 }
23176 arg2 = static_cast< unsigned int >(val2);
23177 if (arg1) (arg1)->m_rawFlags = arg2;
23178
23179 resultobj = SWIG_Py_Void();
23180 return resultobj;
23181 fail:
23182 return NULL;
23183 }
23184
23185
23186 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23187 PyObject *resultobj = 0;
23188 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23189 unsigned int result;
23190 void *argp1 = 0 ;
23191 int res1 = 0 ;
23192 PyObject *swig_obj[1] ;
23193
23194 if (!args) SWIG_fail;
23195 swig_obj[0] = args;
23196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23197 if (!SWIG_IsOK(res1)) {
23198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23199 }
23200 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23201 result = (unsigned int) ((arg1)->m_rawFlags);
23202 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23203 return resultobj;
23204 fail:
23205 return NULL;
23206 }
23207
23208
23209 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23210 PyObject *obj;
23211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23212 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23213 return SWIG_Py_Void();
23214 }
23215
23216 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23217 return SWIG_Python_InitShadowInstance(args);
23218 }
23219
23220 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23221 PyObject *resultobj = 0;
23222 wxSize const &arg1_defvalue = wxDefaultSize ;
23223 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23224 int arg2 = (int) 0 ;
23225 wxSizeEvent *result = 0 ;
23226 wxSize temp1 ;
23227 int val2 ;
23228 int ecode2 = 0 ;
23229 PyObject * obj0 = 0 ;
23230 PyObject * obj1 = 0 ;
23231 char * kwnames[] = {
23232 (char *) "sz",(char *) "winid", NULL
23233 };
23234
23235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23236 if (obj0) {
23237 {
23238 arg1 = &temp1;
23239 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23240 }
23241 }
23242 if (obj1) {
23243 ecode2 = SWIG_AsVal_int(obj1, &val2);
23244 if (!SWIG_IsOK(ecode2)) {
23245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23246 }
23247 arg2 = static_cast< int >(val2);
23248 }
23249 {
23250 PyThreadState* __tstate = wxPyBeginAllowThreads();
23251 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23252 wxPyEndAllowThreads(__tstate);
23253 if (PyErr_Occurred()) SWIG_fail;
23254 }
23255 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23256 return resultobj;
23257 fail:
23258 return NULL;
23259 }
23260
23261
23262 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23263 PyObject *resultobj = 0;
23264 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23265 wxSize result;
23266 void *argp1 = 0 ;
23267 int res1 = 0 ;
23268 PyObject *swig_obj[1] ;
23269
23270 if (!args) SWIG_fail;
23271 swig_obj[0] = args;
23272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23273 if (!SWIG_IsOK(res1)) {
23274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23275 }
23276 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23277 {
23278 PyThreadState* __tstate = wxPyBeginAllowThreads();
23279 result = ((wxSizeEvent const *)arg1)->GetSize();
23280 wxPyEndAllowThreads(__tstate);
23281 if (PyErr_Occurred()) SWIG_fail;
23282 }
23283 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23284 return resultobj;
23285 fail:
23286 return NULL;
23287 }
23288
23289
23290 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23291 PyObject *resultobj = 0;
23292 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23293 wxRect result;
23294 void *argp1 = 0 ;
23295 int res1 = 0 ;
23296 PyObject *swig_obj[1] ;
23297
23298 if (!args) SWIG_fail;
23299 swig_obj[0] = args;
23300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23301 if (!SWIG_IsOK(res1)) {
23302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23303 }
23304 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23305 {
23306 PyThreadState* __tstate = wxPyBeginAllowThreads();
23307 result = ((wxSizeEvent const *)arg1)->GetRect();
23308 wxPyEndAllowThreads(__tstate);
23309 if (PyErr_Occurred()) SWIG_fail;
23310 }
23311 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23312 return resultobj;
23313 fail:
23314 return NULL;
23315 }
23316
23317
23318 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23319 PyObject *resultobj = 0;
23320 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23321 wxRect arg2 ;
23322 void *argp1 = 0 ;
23323 int res1 = 0 ;
23324 void *argp2 ;
23325 int res2 = 0 ;
23326 PyObject * obj0 = 0 ;
23327 PyObject * obj1 = 0 ;
23328 char * kwnames[] = {
23329 (char *) "self",(char *) "rect", NULL
23330 };
23331
23332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23334 if (!SWIG_IsOK(res1)) {
23335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23336 }
23337 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23338 {
23339 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23340 if (!SWIG_IsOK(res2)) {
23341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23342 }
23343 if (!argp2) {
23344 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23345 } else {
23346 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23347 arg2 = *temp;
23348 if (SWIG_IsNewObj(res2)) delete temp;
23349 }
23350 }
23351 {
23352 PyThreadState* __tstate = wxPyBeginAllowThreads();
23353 (arg1)->SetRect(arg2);
23354 wxPyEndAllowThreads(__tstate);
23355 if (PyErr_Occurred()) SWIG_fail;
23356 }
23357 resultobj = SWIG_Py_Void();
23358 return resultobj;
23359 fail:
23360 return NULL;
23361 }
23362
23363
23364 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23365 PyObject *resultobj = 0;
23366 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23367 wxSize arg2 ;
23368 void *argp1 = 0 ;
23369 int res1 = 0 ;
23370 void *argp2 ;
23371 int res2 = 0 ;
23372 PyObject * obj0 = 0 ;
23373 PyObject * obj1 = 0 ;
23374 char * kwnames[] = {
23375 (char *) "self",(char *) "size", NULL
23376 };
23377
23378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23380 if (!SWIG_IsOK(res1)) {
23381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23382 }
23383 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23384 {
23385 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23386 if (!SWIG_IsOK(res2)) {
23387 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23388 }
23389 if (!argp2) {
23390 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23391 } else {
23392 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23393 arg2 = *temp;
23394 if (SWIG_IsNewObj(res2)) delete temp;
23395 }
23396 }
23397 {
23398 PyThreadState* __tstate = wxPyBeginAllowThreads();
23399 wxSizeEvent_SetSize(arg1,arg2);
23400 wxPyEndAllowThreads(__tstate);
23401 if (PyErr_Occurred()) SWIG_fail;
23402 }
23403 resultobj = SWIG_Py_Void();
23404 return resultobj;
23405 fail:
23406 return NULL;
23407 }
23408
23409
23410 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23411 PyObject *resultobj = 0;
23412 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23413 wxSize *arg2 = (wxSize *) 0 ;
23414 void *argp1 = 0 ;
23415 int res1 = 0 ;
23416 void *argp2 = 0 ;
23417 int res2 = 0 ;
23418 PyObject *swig_obj[2] ;
23419
23420 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23422 if (!SWIG_IsOK(res1)) {
23423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23424 }
23425 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23426 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23427 if (!SWIG_IsOK(res2)) {
23428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23429 }
23430 arg2 = reinterpret_cast< wxSize * >(argp2);
23431 if (arg1) (arg1)->m_size = *arg2;
23432
23433 resultobj = SWIG_Py_Void();
23434 return resultobj;
23435 fail:
23436 return NULL;
23437 }
23438
23439
23440 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23441 PyObject *resultobj = 0;
23442 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23443 wxSize *result = 0 ;
23444 void *argp1 = 0 ;
23445 int res1 = 0 ;
23446 PyObject *swig_obj[1] ;
23447
23448 if (!args) SWIG_fail;
23449 swig_obj[0] = args;
23450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23451 if (!SWIG_IsOK(res1)) {
23452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23453 }
23454 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23455 result = (wxSize *)& ((arg1)->m_size);
23456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23457 return resultobj;
23458 fail:
23459 return NULL;
23460 }
23461
23462
23463 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23464 PyObject *resultobj = 0;
23465 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23466 wxRect *arg2 = (wxRect *) 0 ;
23467 void *argp1 = 0 ;
23468 int res1 = 0 ;
23469 void *argp2 = 0 ;
23470 int res2 = 0 ;
23471 PyObject *swig_obj[2] ;
23472
23473 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23475 if (!SWIG_IsOK(res1)) {
23476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23477 }
23478 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23479 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23480 if (!SWIG_IsOK(res2)) {
23481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23482 }
23483 arg2 = reinterpret_cast< wxRect * >(argp2);
23484 if (arg1) (arg1)->m_rect = *arg2;
23485
23486 resultobj = SWIG_Py_Void();
23487 return resultobj;
23488 fail:
23489 return NULL;
23490 }
23491
23492
23493 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23494 PyObject *resultobj = 0;
23495 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23496 wxRect *result = 0 ;
23497 void *argp1 = 0 ;
23498 int res1 = 0 ;
23499 PyObject *swig_obj[1] ;
23500
23501 if (!args) SWIG_fail;
23502 swig_obj[0] = args;
23503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23504 if (!SWIG_IsOK(res1)) {
23505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23506 }
23507 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23508 result = (wxRect *)& ((arg1)->m_rect);
23509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23510 return resultobj;
23511 fail:
23512 return NULL;
23513 }
23514
23515
23516 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23517 PyObject *obj;
23518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23519 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23520 return SWIG_Py_Void();
23521 }
23522
23523 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23524 return SWIG_Python_InitShadowInstance(args);
23525 }
23526
23527 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23528 PyObject *resultobj = 0;
23529 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23530 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23531 int arg2 = (int) 0 ;
23532 wxMoveEvent *result = 0 ;
23533 wxPoint temp1 ;
23534 int val2 ;
23535 int ecode2 = 0 ;
23536 PyObject * obj0 = 0 ;
23537 PyObject * obj1 = 0 ;
23538 char * kwnames[] = {
23539 (char *) "pos",(char *) "winid", NULL
23540 };
23541
23542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23543 if (obj0) {
23544 {
23545 arg1 = &temp1;
23546 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23547 }
23548 }
23549 if (obj1) {
23550 ecode2 = SWIG_AsVal_int(obj1, &val2);
23551 if (!SWIG_IsOK(ecode2)) {
23552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23553 }
23554 arg2 = static_cast< int >(val2);
23555 }
23556 {
23557 PyThreadState* __tstate = wxPyBeginAllowThreads();
23558 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23559 wxPyEndAllowThreads(__tstate);
23560 if (PyErr_Occurred()) SWIG_fail;
23561 }
23562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23563 return resultobj;
23564 fail:
23565 return NULL;
23566 }
23567
23568
23569 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23570 PyObject *resultobj = 0;
23571 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23572 wxPoint result;
23573 void *argp1 = 0 ;
23574 int res1 = 0 ;
23575 PyObject *swig_obj[1] ;
23576
23577 if (!args) SWIG_fail;
23578 swig_obj[0] = args;
23579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23580 if (!SWIG_IsOK(res1)) {
23581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23582 }
23583 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23584 {
23585 PyThreadState* __tstate = wxPyBeginAllowThreads();
23586 result = ((wxMoveEvent const *)arg1)->GetPosition();
23587 wxPyEndAllowThreads(__tstate);
23588 if (PyErr_Occurred()) SWIG_fail;
23589 }
23590 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23591 return resultobj;
23592 fail:
23593 return NULL;
23594 }
23595
23596
23597 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23598 PyObject *resultobj = 0;
23599 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23600 wxRect result;
23601 void *argp1 = 0 ;
23602 int res1 = 0 ;
23603 PyObject *swig_obj[1] ;
23604
23605 if (!args) SWIG_fail;
23606 swig_obj[0] = args;
23607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23608 if (!SWIG_IsOK(res1)) {
23609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23610 }
23611 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23612 {
23613 PyThreadState* __tstate = wxPyBeginAllowThreads();
23614 result = ((wxMoveEvent const *)arg1)->GetRect();
23615 wxPyEndAllowThreads(__tstate);
23616 if (PyErr_Occurred()) SWIG_fail;
23617 }
23618 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23619 return resultobj;
23620 fail:
23621 return NULL;
23622 }
23623
23624
23625 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23626 PyObject *resultobj = 0;
23627 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23628 wxRect *arg2 = 0 ;
23629 void *argp1 = 0 ;
23630 int res1 = 0 ;
23631 wxRect temp2 ;
23632 PyObject * obj0 = 0 ;
23633 PyObject * obj1 = 0 ;
23634 char * kwnames[] = {
23635 (char *) "self",(char *) "rect", NULL
23636 };
23637
23638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23640 if (!SWIG_IsOK(res1)) {
23641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23642 }
23643 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23644 {
23645 arg2 = &temp2;
23646 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23647 }
23648 {
23649 PyThreadState* __tstate = wxPyBeginAllowThreads();
23650 (arg1)->SetRect((wxRect const &)*arg2);
23651 wxPyEndAllowThreads(__tstate);
23652 if (PyErr_Occurred()) SWIG_fail;
23653 }
23654 resultobj = SWIG_Py_Void();
23655 return resultobj;
23656 fail:
23657 return NULL;
23658 }
23659
23660
23661 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23662 PyObject *resultobj = 0;
23663 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23664 wxPoint *arg2 = 0 ;
23665 void *argp1 = 0 ;
23666 int res1 = 0 ;
23667 wxPoint temp2 ;
23668 PyObject * obj0 = 0 ;
23669 PyObject * obj1 = 0 ;
23670 char * kwnames[] = {
23671 (char *) "self",(char *) "pos", NULL
23672 };
23673
23674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23676 if (!SWIG_IsOK(res1)) {
23677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23678 }
23679 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23680 {
23681 arg2 = &temp2;
23682 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23683 }
23684 {
23685 PyThreadState* __tstate = wxPyBeginAllowThreads();
23686 (arg1)->SetPosition((wxPoint const &)*arg2);
23687 wxPyEndAllowThreads(__tstate);
23688 if (PyErr_Occurred()) SWIG_fail;
23689 }
23690 resultobj = SWIG_Py_Void();
23691 return resultobj;
23692 fail:
23693 return NULL;
23694 }
23695
23696
23697 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23698 PyObject *obj;
23699 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23700 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23701 return SWIG_Py_Void();
23702 }
23703
23704 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23705 return SWIG_Python_InitShadowInstance(args);
23706 }
23707
23708 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23709 PyObject *resultobj = 0;
23710 int arg1 = (int) 0 ;
23711 wxPaintEvent *result = 0 ;
23712 int val1 ;
23713 int ecode1 = 0 ;
23714 PyObject * obj0 = 0 ;
23715 char * kwnames[] = {
23716 (char *) "Id", NULL
23717 };
23718
23719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23720 if (obj0) {
23721 ecode1 = SWIG_AsVal_int(obj0, &val1);
23722 if (!SWIG_IsOK(ecode1)) {
23723 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23724 }
23725 arg1 = static_cast< int >(val1);
23726 }
23727 {
23728 PyThreadState* __tstate = wxPyBeginAllowThreads();
23729 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23730 wxPyEndAllowThreads(__tstate);
23731 if (PyErr_Occurred()) SWIG_fail;
23732 }
23733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23741 PyObject *obj;
23742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23743 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23744 return SWIG_Py_Void();
23745 }
23746
23747 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23748 return SWIG_Python_InitShadowInstance(args);
23749 }
23750
23751 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23752 PyObject *resultobj = 0;
23753 int arg1 = (int) 0 ;
23754 wxNcPaintEvent *result = 0 ;
23755 int val1 ;
23756 int ecode1 = 0 ;
23757 PyObject * obj0 = 0 ;
23758 char * kwnames[] = {
23759 (char *) "winid", NULL
23760 };
23761
23762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23763 if (obj0) {
23764 ecode1 = SWIG_AsVal_int(obj0, &val1);
23765 if (!SWIG_IsOK(ecode1)) {
23766 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23767 }
23768 arg1 = static_cast< int >(val1);
23769 }
23770 {
23771 PyThreadState* __tstate = wxPyBeginAllowThreads();
23772 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23773 wxPyEndAllowThreads(__tstate);
23774 if (PyErr_Occurred()) SWIG_fail;
23775 }
23776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23777 return resultobj;
23778 fail:
23779 return NULL;
23780 }
23781
23782
23783 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23784 PyObject *obj;
23785 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23786 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23787 return SWIG_Py_Void();
23788 }
23789
23790 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23791 return SWIG_Python_InitShadowInstance(args);
23792 }
23793
23794 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23795 PyObject *resultobj = 0;
23796 int arg1 = (int) 0 ;
23797 wxDC *arg2 = (wxDC *) NULL ;
23798 wxEraseEvent *result = 0 ;
23799 int val1 ;
23800 int ecode1 = 0 ;
23801 void *argp2 = 0 ;
23802 int res2 = 0 ;
23803 PyObject * obj0 = 0 ;
23804 PyObject * obj1 = 0 ;
23805 char * kwnames[] = {
23806 (char *) "Id",(char *) "dc", NULL
23807 };
23808
23809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23810 if (obj0) {
23811 ecode1 = SWIG_AsVal_int(obj0, &val1);
23812 if (!SWIG_IsOK(ecode1)) {
23813 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23814 }
23815 arg1 = static_cast< int >(val1);
23816 }
23817 if (obj1) {
23818 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23819 if (!SWIG_IsOK(res2)) {
23820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23821 }
23822 arg2 = reinterpret_cast< wxDC * >(argp2);
23823 }
23824 {
23825 PyThreadState* __tstate = wxPyBeginAllowThreads();
23826 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23827 wxPyEndAllowThreads(__tstate);
23828 if (PyErr_Occurred()) SWIG_fail;
23829 }
23830 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23831 return resultobj;
23832 fail:
23833 return NULL;
23834 }
23835
23836
23837 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23838 PyObject *resultobj = 0;
23839 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23840 wxDC *result = 0 ;
23841 void *argp1 = 0 ;
23842 int res1 = 0 ;
23843 PyObject *swig_obj[1] ;
23844
23845 if (!args) SWIG_fail;
23846 swig_obj[0] = args;
23847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23848 if (!SWIG_IsOK(res1)) {
23849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23850 }
23851 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23852 {
23853 PyThreadState* __tstate = wxPyBeginAllowThreads();
23854 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23855 wxPyEndAllowThreads(__tstate);
23856 if (PyErr_Occurred()) SWIG_fail;
23857 }
23858 {
23859 resultobj = wxPyMake_wxObject(result, (bool)0);
23860 }
23861 return resultobj;
23862 fail:
23863 return NULL;
23864 }
23865
23866
23867 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23868 PyObject *obj;
23869 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23870 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23871 return SWIG_Py_Void();
23872 }
23873
23874 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23875 return SWIG_Python_InitShadowInstance(args);
23876 }
23877
23878 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23879 PyObject *resultobj = 0;
23880 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23881 int arg2 = (int) 0 ;
23882 wxFocusEvent *result = 0 ;
23883 int val1 ;
23884 int ecode1 = 0 ;
23885 int val2 ;
23886 int ecode2 = 0 ;
23887 PyObject * obj0 = 0 ;
23888 PyObject * obj1 = 0 ;
23889 char * kwnames[] = {
23890 (char *) "type",(char *) "winid", NULL
23891 };
23892
23893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23894 if (obj0) {
23895 ecode1 = SWIG_AsVal_int(obj0, &val1);
23896 if (!SWIG_IsOK(ecode1)) {
23897 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23898 }
23899 arg1 = static_cast< wxEventType >(val1);
23900 }
23901 if (obj1) {
23902 ecode2 = SWIG_AsVal_int(obj1, &val2);
23903 if (!SWIG_IsOK(ecode2)) {
23904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23905 }
23906 arg2 = static_cast< int >(val2);
23907 }
23908 {
23909 PyThreadState* __tstate = wxPyBeginAllowThreads();
23910 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23911 wxPyEndAllowThreads(__tstate);
23912 if (PyErr_Occurred()) SWIG_fail;
23913 }
23914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23915 return resultobj;
23916 fail:
23917 return NULL;
23918 }
23919
23920
23921 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23922 PyObject *resultobj = 0;
23923 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23924 wxWindow *result = 0 ;
23925 void *argp1 = 0 ;
23926 int res1 = 0 ;
23927 PyObject *swig_obj[1] ;
23928
23929 if (!args) SWIG_fail;
23930 swig_obj[0] = args;
23931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23932 if (!SWIG_IsOK(res1)) {
23933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23934 }
23935 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23936 {
23937 PyThreadState* __tstate = wxPyBeginAllowThreads();
23938 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23939 wxPyEndAllowThreads(__tstate);
23940 if (PyErr_Occurred()) SWIG_fail;
23941 }
23942 {
23943 resultobj = wxPyMake_wxObject(result, (bool)0);
23944 }
23945 return resultobj;
23946 fail:
23947 return NULL;
23948 }
23949
23950
23951 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23952 PyObject *resultobj = 0;
23953 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23954 wxWindow *arg2 = (wxWindow *) 0 ;
23955 void *argp1 = 0 ;
23956 int res1 = 0 ;
23957 void *argp2 = 0 ;
23958 int res2 = 0 ;
23959 PyObject * obj0 = 0 ;
23960 PyObject * obj1 = 0 ;
23961 char * kwnames[] = {
23962 (char *) "self",(char *) "win", NULL
23963 };
23964
23965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23967 if (!SWIG_IsOK(res1)) {
23968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23969 }
23970 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23971 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23972 if (!SWIG_IsOK(res2)) {
23973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23974 }
23975 arg2 = reinterpret_cast< wxWindow * >(argp2);
23976 {
23977 PyThreadState* __tstate = wxPyBeginAllowThreads();
23978 (arg1)->SetWindow(arg2);
23979 wxPyEndAllowThreads(__tstate);
23980 if (PyErr_Occurred()) SWIG_fail;
23981 }
23982 resultobj = SWIG_Py_Void();
23983 return resultobj;
23984 fail:
23985 return NULL;
23986 }
23987
23988
23989 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23990 PyObject *obj;
23991 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23992 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23993 return SWIG_Py_Void();
23994 }
23995
23996 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23997 return SWIG_Python_InitShadowInstance(args);
23998 }
23999
24000 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24001 PyObject *resultobj = 0;
24002 wxWindow *arg1 = (wxWindow *) NULL ;
24003 wxChildFocusEvent *result = 0 ;
24004 void *argp1 = 0 ;
24005 int res1 = 0 ;
24006 PyObject * obj0 = 0 ;
24007 char * kwnames[] = {
24008 (char *) "win", NULL
24009 };
24010
24011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24012 if (obj0) {
24013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24014 if (!SWIG_IsOK(res1)) {
24015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24016 }
24017 arg1 = reinterpret_cast< wxWindow * >(argp1);
24018 }
24019 {
24020 PyThreadState* __tstate = wxPyBeginAllowThreads();
24021 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24026 return resultobj;
24027 fail:
24028 return NULL;
24029 }
24030
24031
24032 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24033 PyObject *resultobj = 0;
24034 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24035 wxWindow *result = 0 ;
24036 void *argp1 = 0 ;
24037 int res1 = 0 ;
24038 PyObject *swig_obj[1] ;
24039
24040 if (!args) SWIG_fail;
24041 swig_obj[0] = args;
24042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24043 if (!SWIG_IsOK(res1)) {
24044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24045 }
24046 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24047 {
24048 PyThreadState* __tstate = wxPyBeginAllowThreads();
24049 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24050 wxPyEndAllowThreads(__tstate);
24051 if (PyErr_Occurred()) SWIG_fail;
24052 }
24053 {
24054 resultobj = wxPyMake_wxObject(result, (bool)0);
24055 }
24056 return resultobj;
24057 fail:
24058 return NULL;
24059 }
24060
24061
24062 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24063 PyObject *obj;
24064 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24065 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24066 return SWIG_Py_Void();
24067 }
24068
24069 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24070 return SWIG_Python_InitShadowInstance(args);
24071 }
24072
24073 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24074 PyObject *resultobj = 0;
24075 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24076 bool arg2 = (bool) true ;
24077 int arg3 = (int) 0 ;
24078 wxActivateEvent *result = 0 ;
24079 int val1 ;
24080 int ecode1 = 0 ;
24081 bool val2 ;
24082 int ecode2 = 0 ;
24083 int val3 ;
24084 int ecode3 = 0 ;
24085 PyObject * obj0 = 0 ;
24086 PyObject * obj1 = 0 ;
24087 PyObject * obj2 = 0 ;
24088 char * kwnames[] = {
24089 (char *) "type",(char *) "active",(char *) "Id", NULL
24090 };
24091
24092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24093 if (obj0) {
24094 ecode1 = SWIG_AsVal_int(obj0, &val1);
24095 if (!SWIG_IsOK(ecode1)) {
24096 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24097 }
24098 arg1 = static_cast< wxEventType >(val1);
24099 }
24100 if (obj1) {
24101 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24102 if (!SWIG_IsOK(ecode2)) {
24103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24104 }
24105 arg2 = static_cast< bool >(val2);
24106 }
24107 if (obj2) {
24108 ecode3 = SWIG_AsVal_int(obj2, &val3);
24109 if (!SWIG_IsOK(ecode3)) {
24110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24111 }
24112 arg3 = static_cast< int >(val3);
24113 }
24114 {
24115 PyThreadState* __tstate = wxPyBeginAllowThreads();
24116 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24117 wxPyEndAllowThreads(__tstate);
24118 if (PyErr_Occurred()) SWIG_fail;
24119 }
24120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24121 return resultobj;
24122 fail:
24123 return NULL;
24124 }
24125
24126
24127 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24128 PyObject *resultobj = 0;
24129 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24130 bool result;
24131 void *argp1 = 0 ;
24132 int res1 = 0 ;
24133 PyObject *swig_obj[1] ;
24134
24135 if (!args) SWIG_fail;
24136 swig_obj[0] = args;
24137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24138 if (!SWIG_IsOK(res1)) {
24139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24140 }
24141 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24142 {
24143 PyThreadState* __tstate = wxPyBeginAllowThreads();
24144 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24145 wxPyEndAllowThreads(__tstate);
24146 if (PyErr_Occurred()) SWIG_fail;
24147 }
24148 {
24149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24150 }
24151 return resultobj;
24152 fail:
24153 return NULL;
24154 }
24155
24156
24157 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24158 PyObject *obj;
24159 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24160 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24161 return SWIG_Py_Void();
24162 }
24163
24164 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24165 return SWIG_Python_InitShadowInstance(args);
24166 }
24167
24168 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24169 PyObject *resultobj = 0;
24170 int arg1 = (int) 0 ;
24171 wxInitDialogEvent *result = 0 ;
24172 int val1 ;
24173 int ecode1 = 0 ;
24174 PyObject * obj0 = 0 ;
24175 char * kwnames[] = {
24176 (char *) "Id", NULL
24177 };
24178
24179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24180 if (obj0) {
24181 ecode1 = SWIG_AsVal_int(obj0, &val1);
24182 if (!SWIG_IsOK(ecode1)) {
24183 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24184 }
24185 arg1 = static_cast< int >(val1);
24186 }
24187 {
24188 PyThreadState* __tstate = wxPyBeginAllowThreads();
24189 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24190 wxPyEndAllowThreads(__tstate);
24191 if (PyErr_Occurred()) SWIG_fail;
24192 }
24193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24194 return resultobj;
24195 fail:
24196 return NULL;
24197 }
24198
24199
24200 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24201 PyObject *obj;
24202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24203 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24204 return SWIG_Py_Void();
24205 }
24206
24207 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24208 return SWIG_Python_InitShadowInstance(args);
24209 }
24210
24211 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24212 PyObject *resultobj = 0;
24213 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24214 int arg2 = (int) 0 ;
24215 wxMenu *arg3 = (wxMenu *) NULL ;
24216 wxMenuEvent *result = 0 ;
24217 int val1 ;
24218 int ecode1 = 0 ;
24219 int val2 ;
24220 int ecode2 = 0 ;
24221 void *argp3 = 0 ;
24222 int res3 = 0 ;
24223 PyObject * obj0 = 0 ;
24224 PyObject * obj1 = 0 ;
24225 PyObject * obj2 = 0 ;
24226 char * kwnames[] = {
24227 (char *) "type",(char *) "winid",(char *) "menu", NULL
24228 };
24229
24230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24231 if (obj0) {
24232 ecode1 = SWIG_AsVal_int(obj0, &val1);
24233 if (!SWIG_IsOK(ecode1)) {
24234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24235 }
24236 arg1 = static_cast< wxEventType >(val1);
24237 }
24238 if (obj1) {
24239 ecode2 = SWIG_AsVal_int(obj1, &val2);
24240 if (!SWIG_IsOK(ecode2)) {
24241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24242 }
24243 arg2 = static_cast< int >(val2);
24244 }
24245 if (obj2) {
24246 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24247 if (!SWIG_IsOK(res3)) {
24248 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24249 }
24250 arg3 = reinterpret_cast< wxMenu * >(argp3);
24251 }
24252 {
24253 PyThreadState* __tstate = wxPyBeginAllowThreads();
24254 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24255 wxPyEndAllowThreads(__tstate);
24256 if (PyErr_Occurred()) SWIG_fail;
24257 }
24258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24259 return resultobj;
24260 fail:
24261 return NULL;
24262 }
24263
24264
24265 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24266 PyObject *resultobj = 0;
24267 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24268 int result;
24269 void *argp1 = 0 ;
24270 int res1 = 0 ;
24271 PyObject *swig_obj[1] ;
24272
24273 if (!args) SWIG_fail;
24274 swig_obj[0] = args;
24275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24276 if (!SWIG_IsOK(res1)) {
24277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24278 }
24279 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24280 {
24281 PyThreadState* __tstate = wxPyBeginAllowThreads();
24282 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24283 wxPyEndAllowThreads(__tstate);
24284 if (PyErr_Occurred()) SWIG_fail;
24285 }
24286 resultobj = SWIG_From_int(static_cast< int >(result));
24287 return resultobj;
24288 fail:
24289 return NULL;
24290 }
24291
24292
24293 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24294 PyObject *resultobj = 0;
24295 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24296 bool result;
24297 void *argp1 = 0 ;
24298 int res1 = 0 ;
24299 PyObject *swig_obj[1] ;
24300
24301 if (!args) SWIG_fail;
24302 swig_obj[0] = args;
24303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24304 if (!SWIG_IsOK(res1)) {
24305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24306 }
24307 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24308 {
24309 PyThreadState* __tstate = wxPyBeginAllowThreads();
24310 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24311 wxPyEndAllowThreads(__tstate);
24312 if (PyErr_Occurred()) SWIG_fail;
24313 }
24314 {
24315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24316 }
24317 return resultobj;
24318 fail:
24319 return NULL;
24320 }
24321
24322
24323 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24324 PyObject *resultobj = 0;
24325 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24326 wxMenu *result = 0 ;
24327 void *argp1 = 0 ;
24328 int res1 = 0 ;
24329 PyObject *swig_obj[1] ;
24330
24331 if (!args) SWIG_fail;
24332 swig_obj[0] = args;
24333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24334 if (!SWIG_IsOK(res1)) {
24335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24336 }
24337 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24338 {
24339 PyThreadState* __tstate = wxPyBeginAllowThreads();
24340 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24341 wxPyEndAllowThreads(__tstate);
24342 if (PyErr_Occurred()) SWIG_fail;
24343 }
24344 {
24345 resultobj = wxPyMake_wxObject(result, (bool)0);
24346 }
24347 return resultobj;
24348 fail:
24349 return NULL;
24350 }
24351
24352
24353 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24354 PyObject *obj;
24355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24356 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24357 return SWIG_Py_Void();
24358 }
24359
24360 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24361 return SWIG_Python_InitShadowInstance(args);
24362 }
24363
24364 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24365 PyObject *resultobj = 0;
24366 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24367 int arg2 = (int) 0 ;
24368 wxCloseEvent *result = 0 ;
24369 int val1 ;
24370 int ecode1 = 0 ;
24371 int val2 ;
24372 int ecode2 = 0 ;
24373 PyObject * obj0 = 0 ;
24374 PyObject * obj1 = 0 ;
24375 char * kwnames[] = {
24376 (char *) "type",(char *) "winid", NULL
24377 };
24378
24379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24380 if (obj0) {
24381 ecode1 = SWIG_AsVal_int(obj0, &val1);
24382 if (!SWIG_IsOK(ecode1)) {
24383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24384 }
24385 arg1 = static_cast< wxEventType >(val1);
24386 }
24387 if (obj1) {
24388 ecode2 = SWIG_AsVal_int(obj1, &val2);
24389 if (!SWIG_IsOK(ecode2)) {
24390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24391 }
24392 arg2 = static_cast< int >(val2);
24393 }
24394 {
24395 PyThreadState* __tstate = wxPyBeginAllowThreads();
24396 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24397 wxPyEndAllowThreads(__tstate);
24398 if (PyErr_Occurred()) SWIG_fail;
24399 }
24400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24401 return resultobj;
24402 fail:
24403 return NULL;
24404 }
24405
24406
24407 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24408 PyObject *resultobj = 0;
24409 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24410 bool arg2 ;
24411 void *argp1 = 0 ;
24412 int res1 = 0 ;
24413 bool val2 ;
24414 int ecode2 = 0 ;
24415 PyObject * obj0 = 0 ;
24416 PyObject * obj1 = 0 ;
24417 char * kwnames[] = {
24418 (char *) "self",(char *) "logOff", NULL
24419 };
24420
24421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24423 if (!SWIG_IsOK(res1)) {
24424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24425 }
24426 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24427 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24428 if (!SWIG_IsOK(ecode2)) {
24429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24430 }
24431 arg2 = static_cast< bool >(val2);
24432 {
24433 PyThreadState* __tstate = wxPyBeginAllowThreads();
24434 (arg1)->SetLoggingOff(arg2);
24435 wxPyEndAllowThreads(__tstate);
24436 if (PyErr_Occurred()) SWIG_fail;
24437 }
24438 resultobj = SWIG_Py_Void();
24439 return resultobj;
24440 fail:
24441 return NULL;
24442 }
24443
24444
24445 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24446 PyObject *resultobj = 0;
24447 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24448 bool result;
24449 void *argp1 = 0 ;
24450 int res1 = 0 ;
24451 PyObject *swig_obj[1] ;
24452
24453 if (!args) SWIG_fail;
24454 swig_obj[0] = args;
24455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24456 if (!SWIG_IsOK(res1)) {
24457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24458 }
24459 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24460 {
24461 PyThreadState* __tstate = wxPyBeginAllowThreads();
24462 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24463 wxPyEndAllowThreads(__tstate);
24464 if (PyErr_Occurred()) SWIG_fail;
24465 }
24466 {
24467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24468 }
24469 return resultobj;
24470 fail:
24471 return NULL;
24472 }
24473
24474
24475 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24476 PyObject *resultobj = 0;
24477 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24478 bool arg2 = (bool) true ;
24479 void *argp1 = 0 ;
24480 int res1 = 0 ;
24481 bool val2 ;
24482 int ecode2 = 0 ;
24483 PyObject * obj0 = 0 ;
24484 PyObject * obj1 = 0 ;
24485 char * kwnames[] = {
24486 (char *) "self",(char *) "veto", NULL
24487 };
24488
24489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24491 if (!SWIG_IsOK(res1)) {
24492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24493 }
24494 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24495 if (obj1) {
24496 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24497 if (!SWIG_IsOK(ecode2)) {
24498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24499 }
24500 arg2 = static_cast< bool >(val2);
24501 }
24502 {
24503 PyThreadState* __tstate = wxPyBeginAllowThreads();
24504 (arg1)->Veto(arg2);
24505 wxPyEndAllowThreads(__tstate);
24506 if (PyErr_Occurred()) SWIG_fail;
24507 }
24508 resultobj = SWIG_Py_Void();
24509 return resultobj;
24510 fail:
24511 return NULL;
24512 }
24513
24514
24515 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24516 PyObject *resultobj = 0;
24517 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24518 bool result;
24519 void *argp1 = 0 ;
24520 int res1 = 0 ;
24521 PyObject *swig_obj[1] ;
24522
24523 if (!args) SWIG_fail;
24524 swig_obj[0] = args;
24525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24526 if (!SWIG_IsOK(res1)) {
24527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24528 }
24529 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24530 {
24531 PyThreadState* __tstate = wxPyBeginAllowThreads();
24532 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24533 wxPyEndAllowThreads(__tstate);
24534 if (PyErr_Occurred()) SWIG_fail;
24535 }
24536 {
24537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24538 }
24539 return resultobj;
24540 fail:
24541 return NULL;
24542 }
24543
24544
24545 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24546 PyObject *resultobj = 0;
24547 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24548 bool arg2 ;
24549 void *argp1 = 0 ;
24550 int res1 = 0 ;
24551 bool val2 ;
24552 int ecode2 = 0 ;
24553 PyObject * obj0 = 0 ;
24554 PyObject * obj1 = 0 ;
24555 char * kwnames[] = {
24556 (char *) "self",(char *) "canVeto", NULL
24557 };
24558
24559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24561 if (!SWIG_IsOK(res1)) {
24562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24563 }
24564 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24565 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24566 if (!SWIG_IsOK(ecode2)) {
24567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24568 }
24569 arg2 = static_cast< bool >(val2);
24570 {
24571 PyThreadState* __tstate = wxPyBeginAllowThreads();
24572 (arg1)->SetCanVeto(arg2);
24573 wxPyEndAllowThreads(__tstate);
24574 if (PyErr_Occurred()) SWIG_fail;
24575 }
24576 resultobj = SWIG_Py_Void();
24577 return resultobj;
24578 fail:
24579 return NULL;
24580 }
24581
24582
24583 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24584 PyObject *resultobj = 0;
24585 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24586 bool result;
24587 void *argp1 = 0 ;
24588 int res1 = 0 ;
24589 PyObject *swig_obj[1] ;
24590
24591 if (!args) SWIG_fail;
24592 swig_obj[0] = args;
24593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24594 if (!SWIG_IsOK(res1)) {
24595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24596 }
24597 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24598 {
24599 PyThreadState* __tstate = wxPyBeginAllowThreads();
24600 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24601 wxPyEndAllowThreads(__tstate);
24602 if (PyErr_Occurred()) SWIG_fail;
24603 }
24604 {
24605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24606 }
24607 return resultobj;
24608 fail:
24609 return NULL;
24610 }
24611
24612
24613 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24614 PyObject *obj;
24615 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24616 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24617 return SWIG_Py_Void();
24618 }
24619
24620 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24621 return SWIG_Python_InitShadowInstance(args);
24622 }
24623
24624 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24625 PyObject *resultobj = 0;
24626 int arg1 = (int) 0 ;
24627 bool arg2 = (bool) false ;
24628 wxShowEvent *result = 0 ;
24629 int val1 ;
24630 int ecode1 = 0 ;
24631 bool val2 ;
24632 int ecode2 = 0 ;
24633 PyObject * obj0 = 0 ;
24634 PyObject * obj1 = 0 ;
24635 char * kwnames[] = {
24636 (char *) "winid",(char *) "show", NULL
24637 };
24638
24639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24640 if (obj0) {
24641 ecode1 = SWIG_AsVal_int(obj0, &val1);
24642 if (!SWIG_IsOK(ecode1)) {
24643 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24644 }
24645 arg1 = static_cast< int >(val1);
24646 }
24647 if (obj1) {
24648 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24649 if (!SWIG_IsOK(ecode2)) {
24650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24651 }
24652 arg2 = static_cast< bool >(val2);
24653 }
24654 {
24655 PyThreadState* __tstate = wxPyBeginAllowThreads();
24656 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24657 wxPyEndAllowThreads(__tstate);
24658 if (PyErr_Occurred()) SWIG_fail;
24659 }
24660 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24661 return resultobj;
24662 fail:
24663 return NULL;
24664 }
24665
24666
24667 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24668 PyObject *resultobj = 0;
24669 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24670 bool arg2 ;
24671 void *argp1 = 0 ;
24672 int res1 = 0 ;
24673 bool val2 ;
24674 int ecode2 = 0 ;
24675 PyObject * obj0 = 0 ;
24676 PyObject * obj1 = 0 ;
24677 char * kwnames[] = {
24678 (char *) "self",(char *) "show", NULL
24679 };
24680
24681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24683 if (!SWIG_IsOK(res1)) {
24684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24685 }
24686 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24687 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24688 if (!SWIG_IsOK(ecode2)) {
24689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24690 }
24691 arg2 = static_cast< bool >(val2);
24692 {
24693 PyThreadState* __tstate = wxPyBeginAllowThreads();
24694 (arg1)->SetShow(arg2);
24695 wxPyEndAllowThreads(__tstate);
24696 if (PyErr_Occurred()) SWIG_fail;
24697 }
24698 resultobj = SWIG_Py_Void();
24699 return resultobj;
24700 fail:
24701 return NULL;
24702 }
24703
24704
24705 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24706 PyObject *resultobj = 0;
24707 wxShowEvent *arg1 = (wxShowEvent *) 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_wxShowEvent, 0 | 0 );
24716 if (!SWIG_IsOK(res1)) {
24717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24718 }
24719 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24720 {
24721 PyThreadState* __tstate = wxPyBeginAllowThreads();
24722 result = (bool)((wxShowEvent const *)arg1)->GetShow();
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 *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24736 PyObject *obj;
24737 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24738 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24739 return SWIG_Py_Void();
24740 }
24741
24742 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24743 return SWIG_Python_InitShadowInstance(args);
24744 }
24745
24746 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24747 PyObject *resultobj = 0;
24748 int arg1 = (int) 0 ;
24749 bool arg2 = (bool) true ;
24750 wxIconizeEvent *result = 0 ;
24751 int val1 ;
24752 int ecode1 = 0 ;
24753 bool val2 ;
24754 int ecode2 = 0 ;
24755 PyObject * obj0 = 0 ;
24756 PyObject * obj1 = 0 ;
24757 char * kwnames[] = {
24758 (char *) "id",(char *) "iconized", NULL
24759 };
24760
24761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24762 if (obj0) {
24763 ecode1 = SWIG_AsVal_int(obj0, &val1);
24764 if (!SWIG_IsOK(ecode1)) {
24765 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24766 }
24767 arg1 = static_cast< int >(val1);
24768 }
24769 if (obj1) {
24770 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24771 if (!SWIG_IsOK(ecode2)) {
24772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24773 }
24774 arg2 = static_cast< bool >(val2);
24775 }
24776 {
24777 PyThreadState* __tstate = wxPyBeginAllowThreads();
24778 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24779 wxPyEndAllowThreads(__tstate);
24780 if (PyErr_Occurred()) SWIG_fail;
24781 }
24782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24783 return resultobj;
24784 fail:
24785 return NULL;
24786 }
24787
24788
24789 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24790 PyObject *resultobj = 0;
24791 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24792 bool result;
24793 void *argp1 = 0 ;
24794 int res1 = 0 ;
24795 PyObject *swig_obj[1] ;
24796
24797 if (!args) SWIG_fail;
24798 swig_obj[0] = args;
24799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24800 if (!SWIG_IsOK(res1)) {
24801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24802 }
24803 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24804 {
24805 PyThreadState* __tstate = wxPyBeginAllowThreads();
24806 result = (bool)(arg1)->Iconized();
24807 wxPyEndAllowThreads(__tstate);
24808 if (PyErr_Occurred()) SWIG_fail;
24809 }
24810 {
24811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24812 }
24813 return resultobj;
24814 fail:
24815 return NULL;
24816 }
24817
24818
24819 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24820 PyObject *obj;
24821 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24822 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24823 return SWIG_Py_Void();
24824 }
24825
24826 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24827 return SWIG_Python_InitShadowInstance(args);
24828 }
24829
24830 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24831 PyObject *resultobj = 0;
24832 int arg1 = (int) 0 ;
24833 wxMaximizeEvent *result = 0 ;
24834 int val1 ;
24835 int ecode1 = 0 ;
24836 PyObject * obj0 = 0 ;
24837 char * kwnames[] = {
24838 (char *) "id", NULL
24839 };
24840
24841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24842 if (obj0) {
24843 ecode1 = SWIG_AsVal_int(obj0, &val1);
24844 if (!SWIG_IsOK(ecode1)) {
24845 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24846 }
24847 arg1 = static_cast< int >(val1);
24848 }
24849 {
24850 PyThreadState* __tstate = wxPyBeginAllowThreads();
24851 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24852 wxPyEndAllowThreads(__tstate);
24853 if (PyErr_Occurred()) SWIG_fail;
24854 }
24855 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24856 return resultobj;
24857 fail:
24858 return NULL;
24859 }
24860
24861
24862 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24863 PyObject *obj;
24864 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24865 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24866 return SWIG_Py_Void();
24867 }
24868
24869 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24870 return SWIG_Python_InitShadowInstance(args);
24871 }
24872
24873 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24874 PyObject *resultobj = 0;
24875 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24876 wxPoint result;
24877 void *argp1 = 0 ;
24878 int res1 = 0 ;
24879 PyObject *swig_obj[1] ;
24880
24881 if (!args) SWIG_fail;
24882 swig_obj[0] = args;
24883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24884 if (!SWIG_IsOK(res1)) {
24885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24886 }
24887 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24888 {
24889 PyThreadState* __tstate = wxPyBeginAllowThreads();
24890 result = (arg1)->GetPosition();
24891 wxPyEndAllowThreads(__tstate);
24892 if (PyErr_Occurred()) SWIG_fail;
24893 }
24894 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24895 return resultobj;
24896 fail:
24897 return NULL;
24898 }
24899
24900
24901 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24902 PyObject *resultobj = 0;
24903 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24904 int result;
24905 void *argp1 = 0 ;
24906 int res1 = 0 ;
24907 PyObject *swig_obj[1] ;
24908
24909 if (!args) SWIG_fail;
24910 swig_obj[0] = args;
24911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24912 if (!SWIG_IsOK(res1)) {
24913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24914 }
24915 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24916 {
24917 PyThreadState* __tstate = wxPyBeginAllowThreads();
24918 result = (int)(arg1)->GetNumberOfFiles();
24919 wxPyEndAllowThreads(__tstate);
24920 if (PyErr_Occurred()) SWIG_fail;
24921 }
24922 resultobj = SWIG_From_int(static_cast< int >(result));
24923 return resultobj;
24924 fail:
24925 return NULL;
24926 }
24927
24928
24929 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24930 PyObject *resultobj = 0;
24931 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24932 PyObject *result = 0 ;
24933 void *argp1 = 0 ;
24934 int res1 = 0 ;
24935 PyObject *swig_obj[1] ;
24936
24937 if (!args) SWIG_fail;
24938 swig_obj[0] = args;
24939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24940 if (!SWIG_IsOK(res1)) {
24941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24942 }
24943 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24944 {
24945 PyThreadState* __tstate = wxPyBeginAllowThreads();
24946 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24947 wxPyEndAllowThreads(__tstate);
24948 if (PyErr_Occurred()) SWIG_fail;
24949 }
24950 resultobj = result;
24951 return resultobj;
24952 fail:
24953 return NULL;
24954 }
24955
24956
24957 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24958 PyObject *obj;
24959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24960 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24961 return SWIG_Py_Void();
24962 }
24963
24964 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24965 PyObject *resultobj = 0;
24966 int arg1 = (int) 0 ;
24967 wxUpdateUIEvent *result = 0 ;
24968 int val1 ;
24969 int ecode1 = 0 ;
24970 PyObject * obj0 = 0 ;
24971 char * kwnames[] = {
24972 (char *) "commandId", NULL
24973 };
24974
24975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24976 if (obj0) {
24977 ecode1 = SWIG_AsVal_int(obj0, &val1);
24978 if (!SWIG_IsOK(ecode1)) {
24979 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24980 }
24981 arg1 = static_cast< int >(val1);
24982 }
24983 {
24984 PyThreadState* __tstate = wxPyBeginAllowThreads();
24985 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24986 wxPyEndAllowThreads(__tstate);
24987 if (PyErr_Occurred()) SWIG_fail;
24988 }
24989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24990 return resultobj;
24991 fail:
24992 return NULL;
24993 }
24994
24995
24996 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24997 PyObject *resultobj = 0;
24998 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24999 bool result;
25000 void *argp1 = 0 ;
25001 int res1 = 0 ;
25002 PyObject *swig_obj[1] ;
25003
25004 if (!args) SWIG_fail;
25005 swig_obj[0] = args;
25006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25007 if (!SWIG_IsOK(res1)) {
25008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25009 }
25010 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25011 {
25012 PyThreadState* __tstate = wxPyBeginAllowThreads();
25013 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25014 wxPyEndAllowThreads(__tstate);
25015 if (PyErr_Occurred()) SWIG_fail;
25016 }
25017 {
25018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25019 }
25020 return resultobj;
25021 fail:
25022 return NULL;
25023 }
25024
25025
25026 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25027 PyObject *resultobj = 0;
25028 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25029 bool result;
25030 void *argp1 = 0 ;
25031 int res1 = 0 ;
25032 PyObject *swig_obj[1] ;
25033
25034 if (!args) SWIG_fail;
25035 swig_obj[0] = args;
25036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25037 if (!SWIG_IsOK(res1)) {
25038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25039 }
25040 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25041 {
25042 PyThreadState* __tstate = wxPyBeginAllowThreads();
25043 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25044 wxPyEndAllowThreads(__tstate);
25045 if (PyErr_Occurred()) SWIG_fail;
25046 }
25047 {
25048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25049 }
25050 return resultobj;
25051 fail:
25052 return NULL;
25053 }
25054
25055
25056 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25057 PyObject *resultobj = 0;
25058 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25059 bool result;
25060 void *argp1 = 0 ;
25061 int res1 = 0 ;
25062 PyObject *swig_obj[1] ;
25063
25064 if (!args) SWIG_fail;
25065 swig_obj[0] = args;
25066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25067 if (!SWIG_IsOK(res1)) {
25068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25069 }
25070 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25071 {
25072 PyThreadState* __tstate = wxPyBeginAllowThreads();
25073 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25074 wxPyEndAllowThreads(__tstate);
25075 if (PyErr_Occurred()) SWIG_fail;
25076 }
25077 {
25078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25079 }
25080 return resultobj;
25081 fail:
25082 return NULL;
25083 }
25084
25085
25086 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25087 PyObject *resultobj = 0;
25088 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25089 wxString result;
25090 void *argp1 = 0 ;
25091 int res1 = 0 ;
25092 PyObject *swig_obj[1] ;
25093
25094 if (!args) SWIG_fail;
25095 swig_obj[0] = args;
25096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25097 if (!SWIG_IsOK(res1)) {
25098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25099 }
25100 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25101 {
25102 PyThreadState* __tstate = wxPyBeginAllowThreads();
25103 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25104 wxPyEndAllowThreads(__tstate);
25105 if (PyErr_Occurred()) SWIG_fail;
25106 }
25107 {
25108 #if wxUSE_UNICODE
25109 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25110 #else
25111 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25112 #endif
25113 }
25114 return resultobj;
25115 fail:
25116 return NULL;
25117 }
25118
25119
25120 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25121 PyObject *resultobj = 0;
25122 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25123 bool result;
25124 void *argp1 = 0 ;
25125 int res1 = 0 ;
25126 PyObject *swig_obj[1] ;
25127
25128 if (!args) SWIG_fail;
25129 swig_obj[0] = args;
25130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25131 if (!SWIG_IsOK(res1)) {
25132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25133 }
25134 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25135 {
25136 PyThreadState* __tstate = wxPyBeginAllowThreads();
25137 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25138 wxPyEndAllowThreads(__tstate);
25139 if (PyErr_Occurred()) SWIG_fail;
25140 }
25141 {
25142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25143 }
25144 return resultobj;
25145 fail:
25146 return NULL;
25147 }
25148
25149
25150 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25151 PyObject *resultobj = 0;
25152 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25153 bool result;
25154 void *argp1 = 0 ;
25155 int res1 = 0 ;
25156 PyObject *swig_obj[1] ;
25157
25158 if (!args) SWIG_fail;
25159 swig_obj[0] = args;
25160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25161 if (!SWIG_IsOK(res1)) {
25162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25163 }
25164 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25165 {
25166 PyThreadState* __tstate = wxPyBeginAllowThreads();
25167 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25168 wxPyEndAllowThreads(__tstate);
25169 if (PyErr_Occurred()) SWIG_fail;
25170 }
25171 {
25172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25173 }
25174 return resultobj;
25175 fail:
25176 return NULL;
25177 }
25178
25179
25180 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25181 PyObject *resultobj = 0;
25182 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25183 bool result;
25184 void *argp1 = 0 ;
25185 int res1 = 0 ;
25186 PyObject *swig_obj[1] ;
25187
25188 if (!args) SWIG_fail;
25189 swig_obj[0] = args;
25190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25191 if (!SWIG_IsOK(res1)) {
25192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25193 }
25194 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25195 {
25196 PyThreadState* __tstate = wxPyBeginAllowThreads();
25197 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25198 wxPyEndAllowThreads(__tstate);
25199 if (PyErr_Occurred()) SWIG_fail;
25200 }
25201 {
25202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25203 }
25204 return resultobj;
25205 fail:
25206 return NULL;
25207 }
25208
25209
25210 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25211 PyObject *resultobj = 0;
25212 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25213 bool result;
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_wxUpdateUIEvent, 0 | 0 );
25221 if (!SWIG_IsOK(res1)) {
25222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25223 }
25224 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25225 {
25226 PyThreadState* __tstate = wxPyBeginAllowThreads();
25227 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25228 wxPyEndAllowThreads(__tstate);
25229 if (PyErr_Occurred()) SWIG_fail;
25230 }
25231 {
25232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25233 }
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25241 PyObject *resultobj = 0;
25242 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25243 bool arg2 ;
25244 void *argp1 = 0 ;
25245 int res1 = 0 ;
25246 bool val2 ;
25247 int ecode2 = 0 ;
25248 PyObject * obj0 = 0 ;
25249 PyObject * obj1 = 0 ;
25250 char * kwnames[] = {
25251 (char *) "self",(char *) "check", NULL
25252 };
25253
25254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25256 if (!SWIG_IsOK(res1)) {
25257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25258 }
25259 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25260 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25261 if (!SWIG_IsOK(ecode2)) {
25262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25263 }
25264 arg2 = static_cast< bool >(val2);
25265 {
25266 PyThreadState* __tstate = wxPyBeginAllowThreads();
25267 (arg1)->Check(arg2);
25268 wxPyEndAllowThreads(__tstate);
25269 if (PyErr_Occurred()) SWIG_fail;
25270 }
25271 resultobj = SWIG_Py_Void();
25272 return resultobj;
25273 fail:
25274 return NULL;
25275 }
25276
25277
25278 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25279 PyObject *resultobj = 0;
25280 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25281 bool arg2 ;
25282 void *argp1 = 0 ;
25283 int res1 = 0 ;
25284 bool val2 ;
25285 int ecode2 = 0 ;
25286 PyObject * obj0 = 0 ;
25287 PyObject * obj1 = 0 ;
25288 char * kwnames[] = {
25289 (char *) "self",(char *) "enable", NULL
25290 };
25291
25292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25294 if (!SWIG_IsOK(res1)) {
25295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25296 }
25297 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25298 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25299 if (!SWIG_IsOK(ecode2)) {
25300 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25301 }
25302 arg2 = static_cast< bool >(val2);
25303 {
25304 PyThreadState* __tstate = wxPyBeginAllowThreads();
25305 (arg1)->Enable(arg2);
25306 wxPyEndAllowThreads(__tstate);
25307 if (PyErr_Occurred()) SWIG_fail;
25308 }
25309 resultobj = SWIG_Py_Void();
25310 return resultobj;
25311 fail:
25312 return NULL;
25313 }
25314
25315
25316 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25317 PyObject *resultobj = 0;
25318 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25319 bool arg2 ;
25320 void *argp1 = 0 ;
25321 int res1 = 0 ;
25322 bool val2 ;
25323 int ecode2 = 0 ;
25324 PyObject * obj0 = 0 ;
25325 PyObject * obj1 = 0 ;
25326 char * kwnames[] = {
25327 (char *) "self",(char *) "show", NULL
25328 };
25329
25330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25332 if (!SWIG_IsOK(res1)) {
25333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25334 }
25335 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25336 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25337 if (!SWIG_IsOK(ecode2)) {
25338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25339 }
25340 arg2 = static_cast< bool >(val2);
25341 {
25342 PyThreadState* __tstate = wxPyBeginAllowThreads();
25343 (arg1)->Show(arg2);
25344 wxPyEndAllowThreads(__tstate);
25345 if (PyErr_Occurred()) SWIG_fail;
25346 }
25347 resultobj = SWIG_Py_Void();
25348 return resultobj;
25349 fail:
25350 return NULL;
25351 }
25352
25353
25354 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25355 PyObject *resultobj = 0;
25356 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25357 wxString *arg2 = 0 ;
25358 void *argp1 = 0 ;
25359 int res1 = 0 ;
25360 bool temp2 = false ;
25361 PyObject * obj0 = 0 ;
25362 PyObject * obj1 = 0 ;
25363 char * kwnames[] = {
25364 (char *) "self",(char *) "text", NULL
25365 };
25366
25367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25369 if (!SWIG_IsOK(res1)) {
25370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25371 }
25372 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25373 {
25374 arg2 = wxString_in_helper(obj1);
25375 if (arg2 == NULL) SWIG_fail;
25376 temp2 = true;
25377 }
25378 {
25379 PyThreadState* __tstate = wxPyBeginAllowThreads();
25380 (arg1)->SetText((wxString const &)*arg2);
25381 wxPyEndAllowThreads(__tstate);
25382 if (PyErr_Occurred()) SWIG_fail;
25383 }
25384 resultobj = SWIG_Py_Void();
25385 {
25386 if (temp2)
25387 delete arg2;
25388 }
25389 return resultobj;
25390 fail:
25391 {
25392 if (temp2)
25393 delete arg2;
25394 }
25395 return NULL;
25396 }
25397
25398
25399 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25400 PyObject *resultobj = 0;
25401 long arg1 ;
25402 long val1 ;
25403 int ecode1 = 0 ;
25404 PyObject * obj0 = 0 ;
25405 char * kwnames[] = {
25406 (char *) "updateInterval", NULL
25407 };
25408
25409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25410 ecode1 = SWIG_AsVal_long(obj0, &val1);
25411 if (!SWIG_IsOK(ecode1)) {
25412 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25413 }
25414 arg1 = static_cast< long >(val1);
25415 {
25416 PyThreadState* __tstate = wxPyBeginAllowThreads();
25417 wxUpdateUIEvent::SetUpdateInterval(arg1);
25418 wxPyEndAllowThreads(__tstate);
25419 if (PyErr_Occurred()) SWIG_fail;
25420 }
25421 resultobj = SWIG_Py_Void();
25422 return resultobj;
25423 fail:
25424 return NULL;
25425 }
25426
25427
25428 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25429 PyObject *resultobj = 0;
25430 long result;
25431
25432 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25433 {
25434 PyThreadState* __tstate = wxPyBeginAllowThreads();
25435 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25436 wxPyEndAllowThreads(__tstate);
25437 if (PyErr_Occurred()) SWIG_fail;
25438 }
25439 resultobj = SWIG_From_long(static_cast< long >(result));
25440 return resultobj;
25441 fail:
25442 return NULL;
25443 }
25444
25445
25446 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25447 PyObject *resultobj = 0;
25448 wxWindow *arg1 = (wxWindow *) 0 ;
25449 bool result;
25450 void *argp1 = 0 ;
25451 int res1 = 0 ;
25452 PyObject * obj0 = 0 ;
25453 char * kwnames[] = {
25454 (char *) "win", NULL
25455 };
25456
25457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25459 if (!SWIG_IsOK(res1)) {
25460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25461 }
25462 arg1 = reinterpret_cast< wxWindow * >(argp1);
25463 {
25464 PyThreadState* __tstate = wxPyBeginAllowThreads();
25465 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25466 wxPyEndAllowThreads(__tstate);
25467 if (PyErr_Occurred()) SWIG_fail;
25468 }
25469 {
25470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25471 }
25472 return resultobj;
25473 fail:
25474 return NULL;
25475 }
25476
25477
25478 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25479 PyObject *resultobj = 0;
25480
25481 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25482 {
25483 PyThreadState* __tstate = wxPyBeginAllowThreads();
25484 wxUpdateUIEvent::ResetUpdateTime();
25485 wxPyEndAllowThreads(__tstate);
25486 if (PyErr_Occurred()) SWIG_fail;
25487 }
25488 resultobj = SWIG_Py_Void();
25489 return resultobj;
25490 fail:
25491 return NULL;
25492 }
25493
25494
25495 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25496 PyObject *resultobj = 0;
25497 wxUpdateUIMode arg1 ;
25498 int val1 ;
25499 int ecode1 = 0 ;
25500 PyObject * obj0 = 0 ;
25501 char * kwnames[] = {
25502 (char *) "mode", NULL
25503 };
25504
25505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25506 ecode1 = SWIG_AsVal_int(obj0, &val1);
25507 if (!SWIG_IsOK(ecode1)) {
25508 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25509 }
25510 arg1 = static_cast< wxUpdateUIMode >(val1);
25511 {
25512 PyThreadState* __tstate = wxPyBeginAllowThreads();
25513 wxUpdateUIEvent::SetMode(arg1);
25514 wxPyEndAllowThreads(__tstate);
25515 if (PyErr_Occurred()) SWIG_fail;
25516 }
25517 resultobj = SWIG_Py_Void();
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25525 PyObject *resultobj = 0;
25526 wxUpdateUIMode result;
25527
25528 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25529 {
25530 PyThreadState* __tstate = wxPyBeginAllowThreads();
25531 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25532 wxPyEndAllowThreads(__tstate);
25533 if (PyErr_Occurred()) SWIG_fail;
25534 }
25535 resultobj = SWIG_From_int(static_cast< int >(result));
25536 return resultobj;
25537 fail:
25538 return NULL;
25539 }
25540
25541
25542 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25543 PyObject *obj;
25544 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25545 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25546 return SWIG_Py_Void();
25547 }
25548
25549 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25550 return SWIG_Python_InitShadowInstance(args);
25551 }
25552
25553 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25554 PyObject *resultobj = 0;
25555 wxSysColourChangedEvent *result = 0 ;
25556
25557 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25558 {
25559 PyThreadState* __tstate = wxPyBeginAllowThreads();
25560 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25561 wxPyEndAllowThreads(__tstate);
25562 if (PyErr_Occurred()) SWIG_fail;
25563 }
25564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25565 return resultobj;
25566 fail:
25567 return NULL;
25568 }
25569
25570
25571 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25572 PyObject *obj;
25573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25574 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25575 return SWIG_Py_Void();
25576 }
25577
25578 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25579 return SWIG_Python_InitShadowInstance(args);
25580 }
25581
25582 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25583 PyObject *resultobj = 0;
25584 int arg1 = (int) 0 ;
25585 wxWindow *arg2 = (wxWindow *) NULL ;
25586 wxMouseCaptureChangedEvent *result = 0 ;
25587 int val1 ;
25588 int ecode1 = 0 ;
25589 void *argp2 = 0 ;
25590 int res2 = 0 ;
25591 PyObject * obj0 = 0 ;
25592 PyObject * obj1 = 0 ;
25593 char * kwnames[] = {
25594 (char *) "winid",(char *) "gainedCapture", NULL
25595 };
25596
25597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25598 if (obj0) {
25599 ecode1 = SWIG_AsVal_int(obj0, &val1);
25600 if (!SWIG_IsOK(ecode1)) {
25601 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25602 }
25603 arg1 = static_cast< int >(val1);
25604 }
25605 if (obj1) {
25606 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25607 if (!SWIG_IsOK(res2)) {
25608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25609 }
25610 arg2 = reinterpret_cast< wxWindow * >(argp2);
25611 }
25612 {
25613 PyThreadState* __tstate = wxPyBeginAllowThreads();
25614 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25615 wxPyEndAllowThreads(__tstate);
25616 if (PyErr_Occurred()) SWIG_fail;
25617 }
25618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25619 return resultobj;
25620 fail:
25621 return NULL;
25622 }
25623
25624
25625 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25626 PyObject *resultobj = 0;
25627 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25628 wxWindow *result = 0 ;
25629 void *argp1 = 0 ;
25630 int res1 = 0 ;
25631 PyObject *swig_obj[1] ;
25632
25633 if (!args) SWIG_fail;
25634 swig_obj[0] = args;
25635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25636 if (!SWIG_IsOK(res1)) {
25637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25638 }
25639 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25640 {
25641 PyThreadState* __tstate = wxPyBeginAllowThreads();
25642 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25643 wxPyEndAllowThreads(__tstate);
25644 if (PyErr_Occurred()) SWIG_fail;
25645 }
25646 {
25647 resultobj = wxPyMake_wxObject(result, (bool)0);
25648 }
25649 return resultobj;
25650 fail:
25651 return NULL;
25652 }
25653
25654
25655 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25656 PyObject *obj;
25657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25658 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25659 return SWIG_Py_Void();
25660 }
25661
25662 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25663 return SWIG_Python_InitShadowInstance(args);
25664 }
25665
25666 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25667 PyObject *resultobj = 0;
25668 int arg1 = (int) 0 ;
25669 wxMouseCaptureLostEvent *result = 0 ;
25670 int val1 ;
25671 int ecode1 = 0 ;
25672 PyObject * obj0 = 0 ;
25673 char * kwnames[] = {
25674 (char *) "winid", NULL
25675 };
25676
25677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25678 if (obj0) {
25679 ecode1 = SWIG_AsVal_int(obj0, &val1);
25680 if (!SWIG_IsOK(ecode1)) {
25681 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25682 }
25683 arg1 = static_cast< int >(val1);
25684 }
25685 {
25686 PyThreadState* __tstate = wxPyBeginAllowThreads();
25687 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25688 wxPyEndAllowThreads(__tstate);
25689 if (PyErr_Occurred()) SWIG_fail;
25690 }
25691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25692 return resultobj;
25693 fail:
25694 return NULL;
25695 }
25696
25697
25698 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25699 PyObject *obj;
25700 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25701 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25702 return SWIG_Py_Void();
25703 }
25704
25705 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25706 return SWIG_Python_InitShadowInstance(args);
25707 }
25708
25709 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25710 PyObject *resultobj = 0;
25711 wxDisplayChangedEvent *result = 0 ;
25712
25713 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25714 {
25715 PyThreadState* __tstate = wxPyBeginAllowThreads();
25716 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25717 wxPyEndAllowThreads(__tstate);
25718 if (PyErr_Occurred()) SWIG_fail;
25719 }
25720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25721 return resultobj;
25722 fail:
25723 return NULL;
25724 }
25725
25726
25727 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25728 PyObject *obj;
25729 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25730 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25731 return SWIG_Py_Void();
25732 }
25733
25734 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25735 return SWIG_Python_InitShadowInstance(args);
25736 }
25737
25738 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25739 PyObject *resultobj = 0;
25740 int arg1 = (int) 0 ;
25741 wxPaletteChangedEvent *result = 0 ;
25742 int val1 ;
25743 int ecode1 = 0 ;
25744 PyObject * obj0 = 0 ;
25745 char * kwnames[] = {
25746 (char *) "id", NULL
25747 };
25748
25749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25750 if (obj0) {
25751 ecode1 = SWIG_AsVal_int(obj0, &val1);
25752 if (!SWIG_IsOK(ecode1)) {
25753 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25754 }
25755 arg1 = static_cast< int >(val1);
25756 }
25757 {
25758 PyThreadState* __tstate = wxPyBeginAllowThreads();
25759 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25760 wxPyEndAllowThreads(__tstate);
25761 if (PyErr_Occurred()) SWIG_fail;
25762 }
25763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25764 return resultobj;
25765 fail:
25766 return NULL;
25767 }
25768
25769
25770 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25771 PyObject *resultobj = 0;
25772 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25773 wxWindow *arg2 = (wxWindow *) 0 ;
25774 void *argp1 = 0 ;
25775 int res1 = 0 ;
25776 void *argp2 = 0 ;
25777 int res2 = 0 ;
25778 PyObject * obj0 = 0 ;
25779 PyObject * obj1 = 0 ;
25780 char * kwnames[] = {
25781 (char *) "self",(char *) "win", NULL
25782 };
25783
25784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25786 if (!SWIG_IsOK(res1)) {
25787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25788 }
25789 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25790 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25791 if (!SWIG_IsOK(res2)) {
25792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25793 }
25794 arg2 = reinterpret_cast< wxWindow * >(argp2);
25795 {
25796 PyThreadState* __tstate = wxPyBeginAllowThreads();
25797 (arg1)->SetChangedWindow(arg2);
25798 wxPyEndAllowThreads(__tstate);
25799 if (PyErr_Occurred()) SWIG_fail;
25800 }
25801 resultobj = SWIG_Py_Void();
25802 return resultobj;
25803 fail:
25804 return NULL;
25805 }
25806
25807
25808 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25809 PyObject *resultobj = 0;
25810 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25811 wxWindow *result = 0 ;
25812 void *argp1 = 0 ;
25813 int res1 = 0 ;
25814 PyObject *swig_obj[1] ;
25815
25816 if (!args) SWIG_fail;
25817 swig_obj[0] = args;
25818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25819 if (!SWIG_IsOK(res1)) {
25820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25821 }
25822 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25823 {
25824 PyThreadState* __tstate = wxPyBeginAllowThreads();
25825 result = (wxWindow *)(arg1)->GetChangedWindow();
25826 wxPyEndAllowThreads(__tstate);
25827 if (PyErr_Occurred()) SWIG_fail;
25828 }
25829 {
25830 resultobj = wxPyMake_wxObject(result, (bool)0);
25831 }
25832 return resultobj;
25833 fail:
25834 return NULL;
25835 }
25836
25837
25838 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25839 PyObject *obj;
25840 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25841 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25842 return SWIG_Py_Void();
25843 }
25844
25845 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25846 return SWIG_Python_InitShadowInstance(args);
25847 }
25848
25849 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25850 PyObject *resultobj = 0;
25851 int arg1 = (int) 0 ;
25852 wxQueryNewPaletteEvent *result = 0 ;
25853 int val1 ;
25854 int ecode1 = 0 ;
25855 PyObject * obj0 = 0 ;
25856 char * kwnames[] = {
25857 (char *) "winid", NULL
25858 };
25859
25860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25861 if (obj0) {
25862 ecode1 = SWIG_AsVal_int(obj0, &val1);
25863 if (!SWIG_IsOK(ecode1)) {
25864 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25865 }
25866 arg1 = static_cast< int >(val1);
25867 }
25868 {
25869 PyThreadState* __tstate = wxPyBeginAllowThreads();
25870 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25871 wxPyEndAllowThreads(__tstate);
25872 if (PyErr_Occurred()) SWIG_fail;
25873 }
25874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25875 return resultobj;
25876 fail:
25877 return NULL;
25878 }
25879
25880
25881 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25882 PyObject *resultobj = 0;
25883 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25884 bool arg2 ;
25885 void *argp1 = 0 ;
25886 int res1 = 0 ;
25887 bool val2 ;
25888 int ecode2 = 0 ;
25889 PyObject * obj0 = 0 ;
25890 PyObject * obj1 = 0 ;
25891 char * kwnames[] = {
25892 (char *) "self",(char *) "realized", NULL
25893 };
25894
25895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25897 if (!SWIG_IsOK(res1)) {
25898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25899 }
25900 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25901 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25902 if (!SWIG_IsOK(ecode2)) {
25903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25904 }
25905 arg2 = static_cast< bool >(val2);
25906 {
25907 PyThreadState* __tstate = wxPyBeginAllowThreads();
25908 (arg1)->SetPaletteRealized(arg2);
25909 wxPyEndAllowThreads(__tstate);
25910 if (PyErr_Occurred()) SWIG_fail;
25911 }
25912 resultobj = SWIG_Py_Void();
25913 return resultobj;
25914 fail:
25915 return NULL;
25916 }
25917
25918
25919 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25920 PyObject *resultobj = 0;
25921 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25922 bool result;
25923 void *argp1 = 0 ;
25924 int res1 = 0 ;
25925 PyObject *swig_obj[1] ;
25926
25927 if (!args) SWIG_fail;
25928 swig_obj[0] = args;
25929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25930 if (!SWIG_IsOK(res1)) {
25931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25932 }
25933 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25934 {
25935 PyThreadState* __tstate = wxPyBeginAllowThreads();
25936 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25937 wxPyEndAllowThreads(__tstate);
25938 if (PyErr_Occurred()) SWIG_fail;
25939 }
25940 {
25941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25942 }
25943 return resultobj;
25944 fail:
25945 return NULL;
25946 }
25947
25948
25949 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25950 PyObject *obj;
25951 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25952 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25953 return SWIG_Py_Void();
25954 }
25955
25956 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25957 return SWIG_Python_InitShadowInstance(args);
25958 }
25959
25960 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25961 PyObject *resultobj = 0;
25962 wxNavigationKeyEvent *result = 0 ;
25963
25964 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25965 {
25966 PyThreadState* __tstate = wxPyBeginAllowThreads();
25967 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25968 wxPyEndAllowThreads(__tstate);
25969 if (PyErr_Occurred()) SWIG_fail;
25970 }
25971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25972 return resultobj;
25973 fail:
25974 return NULL;
25975 }
25976
25977
25978 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25979 PyObject *resultobj = 0;
25980 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25981 bool result;
25982 void *argp1 = 0 ;
25983 int res1 = 0 ;
25984 PyObject *swig_obj[1] ;
25985
25986 if (!args) SWIG_fail;
25987 swig_obj[0] = args;
25988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25989 if (!SWIG_IsOK(res1)) {
25990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25991 }
25992 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25993 {
25994 PyThreadState* __tstate = wxPyBeginAllowThreads();
25995 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25996 wxPyEndAllowThreads(__tstate);
25997 if (PyErr_Occurred()) SWIG_fail;
25998 }
25999 {
26000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26001 }
26002 return resultobj;
26003 fail:
26004 return NULL;
26005 }
26006
26007
26008 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26009 PyObject *resultobj = 0;
26010 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26011 bool arg2 ;
26012 void *argp1 = 0 ;
26013 int res1 = 0 ;
26014 bool val2 ;
26015 int ecode2 = 0 ;
26016 PyObject * obj0 = 0 ;
26017 PyObject * obj1 = 0 ;
26018 char * kwnames[] = {
26019 (char *) "self",(char *) "forward", NULL
26020 };
26021
26022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26024 if (!SWIG_IsOK(res1)) {
26025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26026 }
26027 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26028 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26029 if (!SWIG_IsOK(ecode2)) {
26030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26031 }
26032 arg2 = static_cast< bool >(val2);
26033 {
26034 PyThreadState* __tstate = wxPyBeginAllowThreads();
26035 (arg1)->SetDirection(arg2);
26036 wxPyEndAllowThreads(__tstate);
26037 if (PyErr_Occurred()) SWIG_fail;
26038 }
26039 resultobj = SWIG_Py_Void();
26040 return resultobj;
26041 fail:
26042 return NULL;
26043 }
26044
26045
26046 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26047 PyObject *resultobj = 0;
26048 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26049 bool result;
26050 void *argp1 = 0 ;
26051 int res1 = 0 ;
26052 PyObject *swig_obj[1] ;
26053
26054 if (!args) SWIG_fail;
26055 swig_obj[0] = args;
26056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26057 if (!SWIG_IsOK(res1)) {
26058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26059 }
26060 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26061 {
26062 PyThreadState* __tstate = wxPyBeginAllowThreads();
26063 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26064 wxPyEndAllowThreads(__tstate);
26065 if (PyErr_Occurred()) SWIG_fail;
26066 }
26067 {
26068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26069 }
26070 return resultobj;
26071 fail:
26072 return NULL;
26073 }
26074
26075
26076 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26077 PyObject *resultobj = 0;
26078 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26079 bool arg2 ;
26080 void *argp1 = 0 ;
26081 int res1 = 0 ;
26082 bool val2 ;
26083 int ecode2 = 0 ;
26084 PyObject * obj0 = 0 ;
26085 PyObject * obj1 = 0 ;
26086 char * kwnames[] = {
26087 (char *) "self",(char *) "ischange", NULL
26088 };
26089
26090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26092 if (!SWIG_IsOK(res1)) {
26093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26094 }
26095 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26096 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26097 if (!SWIG_IsOK(ecode2)) {
26098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26099 }
26100 arg2 = static_cast< bool >(val2);
26101 {
26102 PyThreadState* __tstate = wxPyBeginAllowThreads();
26103 (arg1)->SetWindowChange(arg2);
26104 wxPyEndAllowThreads(__tstate);
26105 if (PyErr_Occurred()) SWIG_fail;
26106 }
26107 resultobj = SWIG_Py_Void();
26108 return resultobj;
26109 fail:
26110 return NULL;
26111 }
26112
26113
26114 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26115 PyObject *resultobj = 0;
26116 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26117 bool result;
26118 void *argp1 = 0 ;
26119 int res1 = 0 ;
26120 PyObject *swig_obj[1] ;
26121
26122 if (!args) SWIG_fail;
26123 swig_obj[0] = args;
26124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26125 if (!SWIG_IsOK(res1)) {
26126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26127 }
26128 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26129 {
26130 PyThreadState* __tstate = wxPyBeginAllowThreads();
26131 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26132 wxPyEndAllowThreads(__tstate);
26133 if (PyErr_Occurred()) SWIG_fail;
26134 }
26135 {
26136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26137 }
26138 return resultobj;
26139 fail:
26140 return NULL;
26141 }
26142
26143
26144 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26145 PyObject *resultobj = 0;
26146 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26147 bool arg2 ;
26148 void *argp1 = 0 ;
26149 int res1 = 0 ;
26150 bool val2 ;
26151 int ecode2 = 0 ;
26152 PyObject * obj0 = 0 ;
26153 PyObject * obj1 = 0 ;
26154 char * kwnames[] = {
26155 (char *) "self",(char *) "bIs", NULL
26156 };
26157
26158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26160 if (!SWIG_IsOK(res1)) {
26161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26162 }
26163 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26164 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26165 if (!SWIG_IsOK(ecode2)) {
26166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26167 }
26168 arg2 = static_cast< bool >(val2);
26169 {
26170 PyThreadState* __tstate = wxPyBeginAllowThreads();
26171 (arg1)->SetFromTab(arg2);
26172 wxPyEndAllowThreads(__tstate);
26173 if (PyErr_Occurred()) SWIG_fail;
26174 }
26175 resultobj = SWIG_Py_Void();
26176 return resultobj;
26177 fail:
26178 return NULL;
26179 }
26180
26181
26182 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26183 PyObject *resultobj = 0;
26184 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26185 long arg2 ;
26186 void *argp1 = 0 ;
26187 int res1 = 0 ;
26188 long val2 ;
26189 int ecode2 = 0 ;
26190 PyObject * obj0 = 0 ;
26191 PyObject * obj1 = 0 ;
26192 char * kwnames[] = {
26193 (char *) "self",(char *) "flags", NULL
26194 };
26195
26196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26198 if (!SWIG_IsOK(res1)) {
26199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26200 }
26201 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26202 ecode2 = SWIG_AsVal_long(obj1, &val2);
26203 if (!SWIG_IsOK(ecode2)) {
26204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26205 }
26206 arg2 = static_cast< long >(val2);
26207 {
26208 PyThreadState* __tstate = wxPyBeginAllowThreads();
26209 (arg1)->SetFlags(arg2);
26210 wxPyEndAllowThreads(__tstate);
26211 if (PyErr_Occurred()) SWIG_fail;
26212 }
26213 resultobj = SWIG_Py_Void();
26214 return resultobj;
26215 fail:
26216 return NULL;
26217 }
26218
26219
26220 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26221 PyObject *resultobj = 0;
26222 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26223 wxWindow *result = 0 ;
26224 void *argp1 = 0 ;
26225 int res1 = 0 ;
26226 PyObject *swig_obj[1] ;
26227
26228 if (!args) SWIG_fail;
26229 swig_obj[0] = args;
26230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26231 if (!SWIG_IsOK(res1)) {
26232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26233 }
26234 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26235 {
26236 PyThreadState* __tstate = wxPyBeginAllowThreads();
26237 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26238 wxPyEndAllowThreads(__tstate);
26239 if (PyErr_Occurred()) SWIG_fail;
26240 }
26241 {
26242 resultobj = wxPyMake_wxObject(result, (bool)0);
26243 }
26244 return resultobj;
26245 fail:
26246 return NULL;
26247 }
26248
26249
26250 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26251 PyObject *resultobj = 0;
26252 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26253 wxWindow *arg2 = (wxWindow *) 0 ;
26254 void *argp1 = 0 ;
26255 int res1 = 0 ;
26256 void *argp2 = 0 ;
26257 int res2 = 0 ;
26258 PyObject * obj0 = 0 ;
26259 PyObject * obj1 = 0 ;
26260 char * kwnames[] = {
26261 (char *) "self",(char *) "win", NULL
26262 };
26263
26264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26266 if (!SWIG_IsOK(res1)) {
26267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26268 }
26269 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26270 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26271 if (!SWIG_IsOK(res2)) {
26272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26273 }
26274 arg2 = reinterpret_cast< wxWindow * >(argp2);
26275 {
26276 PyThreadState* __tstate = wxPyBeginAllowThreads();
26277 (arg1)->SetCurrentFocus(arg2);
26278 wxPyEndAllowThreads(__tstate);
26279 if (PyErr_Occurred()) SWIG_fail;
26280 }
26281 resultobj = SWIG_Py_Void();
26282 return resultobj;
26283 fail:
26284 return NULL;
26285 }
26286
26287
26288 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26289 PyObject *obj;
26290 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26291 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26292 return SWIG_Py_Void();
26293 }
26294
26295 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26296 return SWIG_Python_InitShadowInstance(args);
26297 }
26298
26299 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26300 PyObject *resultobj = 0;
26301 wxWindow *arg1 = (wxWindow *) NULL ;
26302 wxWindowCreateEvent *result = 0 ;
26303 void *argp1 = 0 ;
26304 int res1 = 0 ;
26305 PyObject * obj0 = 0 ;
26306 char * kwnames[] = {
26307 (char *) "win", NULL
26308 };
26309
26310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26311 if (obj0) {
26312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26313 if (!SWIG_IsOK(res1)) {
26314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26315 }
26316 arg1 = reinterpret_cast< wxWindow * >(argp1);
26317 }
26318 {
26319 PyThreadState* __tstate = wxPyBeginAllowThreads();
26320 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26321 wxPyEndAllowThreads(__tstate);
26322 if (PyErr_Occurred()) SWIG_fail;
26323 }
26324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26325 return resultobj;
26326 fail:
26327 return NULL;
26328 }
26329
26330
26331 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26332 PyObject *resultobj = 0;
26333 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26334 wxWindow *result = 0 ;
26335 void *argp1 = 0 ;
26336 int res1 = 0 ;
26337 PyObject *swig_obj[1] ;
26338
26339 if (!args) SWIG_fail;
26340 swig_obj[0] = args;
26341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26342 if (!SWIG_IsOK(res1)) {
26343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26344 }
26345 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26346 {
26347 PyThreadState* __tstate = wxPyBeginAllowThreads();
26348 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26349 wxPyEndAllowThreads(__tstate);
26350 if (PyErr_Occurred()) SWIG_fail;
26351 }
26352 {
26353 resultobj = wxPyMake_wxObject(result, (bool)0);
26354 }
26355 return resultobj;
26356 fail:
26357 return NULL;
26358 }
26359
26360
26361 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26362 PyObject *obj;
26363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26364 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26365 return SWIG_Py_Void();
26366 }
26367
26368 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26369 return SWIG_Python_InitShadowInstance(args);
26370 }
26371
26372 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26373 PyObject *resultobj = 0;
26374 wxWindow *arg1 = (wxWindow *) NULL ;
26375 wxWindowDestroyEvent *result = 0 ;
26376 void *argp1 = 0 ;
26377 int res1 = 0 ;
26378 PyObject * obj0 = 0 ;
26379 char * kwnames[] = {
26380 (char *) "win", NULL
26381 };
26382
26383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26384 if (obj0) {
26385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26386 if (!SWIG_IsOK(res1)) {
26387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26388 }
26389 arg1 = reinterpret_cast< wxWindow * >(argp1);
26390 }
26391 {
26392 PyThreadState* __tstate = wxPyBeginAllowThreads();
26393 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26394 wxPyEndAllowThreads(__tstate);
26395 if (PyErr_Occurred()) SWIG_fail;
26396 }
26397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26398 return resultobj;
26399 fail:
26400 return NULL;
26401 }
26402
26403
26404 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26405 PyObject *resultobj = 0;
26406 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26407 wxWindow *result = 0 ;
26408 void *argp1 = 0 ;
26409 int res1 = 0 ;
26410 PyObject *swig_obj[1] ;
26411
26412 if (!args) SWIG_fail;
26413 swig_obj[0] = args;
26414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26415 if (!SWIG_IsOK(res1)) {
26416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26417 }
26418 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26419 {
26420 PyThreadState* __tstate = wxPyBeginAllowThreads();
26421 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26422 wxPyEndAllowThreads(__tstate);
26423 if (PyErr_Occurred()) SWIG_fail;
26424 }
26425 {
26426 resultobj = wxPyMake_wxObject(result, (bool)0);
26427 }
26428 return resultobj;
26429 fail:
26430 return NULL;
26431 }
26432
26433
26434 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26435 PyObject *obj;
26436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26437 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26438 return SWIG_Py_Void();
26439 }
26440
26441 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26442 return SWIG_Python_InitShadowInstance(args);
26443 }
26444
26445 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26446 PyObject *resultobj = 0;
26447 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26448 int arg2 = (int) 0 ;
26449 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26450 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26451 wxContextMenuEvent *result = 0 ;
26452 int val1 ;
26453 int ecode1 = 0 ;
26454 int val2 ;
26455 int ecode2 = 0 ;
26456 wxPoint temp3 ;
26457 PyObject * obj0 = 0 ;
26458 PyObject * obj1 = 0 ;
26459 PyObject * obj2 = 0 ;
26460 char * kwnames[] = {
26461 (char *) "type",(char *) "winid",(char *) "pt", NULL
26462 };
26463
26464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26465 if (obj0) {
26466 ecode1 = SWIG_AsVal_int(obj0, &val1);
26467 if (!SWIG_IsOK(ecode1)) {
26468 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26469 }
26470 arg1 = static_cast< wxEventType >(val1);
26471 }
26472 if (obj1) {
26473 ecode2 = SWIG_AsVal_int(obj1, &val2);
26474 if (!SWIG_IsOK(ecode2)) {
26475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26476 }
26477 arg2 = static_cast< int >(val2);
26478 }
26479 if (obj2) {
26480 {
26481 arg3 = &temp3;
26482 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26483 }
26484 }
26485 {
26486 PyThreadState* __tstate = wxPyBeginAllowThreads();
26487 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26488 wxPyEndAllowThreads(__tstate);
26489 if (PyErr_Occurred()) SWIG_fail;
26490 }
26491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26492 return resultobj;
26493 fail:
26494 return NULL;
26495 }
26496
26497
26498 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26499 PyObject *resultobj = 0;
26500 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26501 wxPoint *result = 0 ;
26502 void *argp1 = 0 ;
26503 int res1 = 0 ;
26504 PyObject *swig_obj[1] ;
26505
26506 if (!args) SWIG_fail;
26507 swig_obj[0] = args;
26508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26509 if (!SWIG_IsOK(res1)) {
26510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26511 }
26512 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26513 {
26514 PyThreadState* __tstate = wxPyBeginAllowThreads();
26515 {
26516 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26517 result = (wxPoint *) &_result_ref;
26518 }
26519 wxPyEndAllowThreads(__tstate);
26520 if (PyErr_Occurred()) SWIG_fail;
26521 }
26522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26523 return resultobj;
26524 fail:
26525 return NULL;
26526 }
26527
26528
26529 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26530 PyObject *resultobj = 0;
26531 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26532 wxPoint *arg2 = 0 ;
26533 void *argp1 = 0 ;
26534 int res1 = 0 ;
26535 wxPoint temp2 ;
26536 PyObject * obj0 = 0 ;
26537 PyObject * obj1 = 0 ;
26538 char * kwnames[] = {
26539 (char *) "self",(char *) "pos", NULL
26540 };
26541
26542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26544 if (!SWIG_IsOK(res1)) {
26545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26546 }
26547 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26548 {
26549 arg2 = &temp2;
26550 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26551 }
26552 {
26553 PyThreadState* __tstate = wxPyBeginAllowThreads();
26554 (arg1)->SetPosition((wxPoint const &)*arg2);
26555 wxPyEndAllowThreads(__tstate);
26556 if (PyErr_Occurred()) SWIG_fail;
26557 }
26558 resultobj = SWIG_Py_Void();
26559 return resultobj;
26560 fail:
26561 return NULL;
26562 }
26563
26564
26565 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26566 PyObject *obj;
26567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26568 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26569 return SWIG_Py_Void();
26570 }
26571
26572 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26573 return SWIG_Python_InitShadowInstance(args);
26574 }
26575
26576 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26577 PyObject *resultobj = 0;
26578 wxIdleEvent *result = 0 ;
26579
26580 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26581 {
26582 PyThreadState* __tstate = wxPyBeginAllowThreads();
26583 result = (wxIdleEvent *)new wxIdleEvent();
26584 wxPyEndAllowThreads(__tstate);
26585 if (PyErr_Occurred()) SWIG_fail;
26586 }
26587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26588 return resultobj;
26589 fail:
26590 return NULL;
26591 }
26592
26593
26594 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26595 PyObject *resultobj = 0;
26596 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26597 bool arg2 = (bool) true ;
26598 void *argp1 = 0 ;
26599 int res1 = 0 ;
26600 bool val2 ;
26601 int ecode2 = 0 ;
26602 PyObject * obj0 = 0 ;
26603 PyObject * obj1 = 0 ;
26604 char * kwnames[] = {
26605 (char *) "self",(char *) "needMore", NULL
26606 };
26607
26608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26610 if (!SWIG_IsOK(res1)) {
26611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26612 }
26613 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26614 if (obj1) {
26615 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26616 if (!SWIG_IsOK(ecode2)) {
26617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26618 }
26619 arg2 = static_cast< bool >(val2);
26620 }
26621 {
26622 PyThreadState* __tstate = wxPyBeginAllowThreads();
26623 (arg1)->RequestMore(arg2);
26624 wxPyEndAllowThreads(__tstate);
26625 if (PyErr_Occurred()) SWIG_fail;
26626 }
26627 resultobj = SWIG_Py_Void();
26628 return resultobj;
26629 fail:
26630 return NULL;
26631 }
26632
26633
26634 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26635 PyObject *resultobj = 0;
26636 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26637 bool result;
26638 void *argp1 = 0 ;
26639 int res1 = 0 ;
26640 PyObject *swig_obj[1] ;
26641
26642 if (!args) SWIG_fail;
26643 swig_obj[0] = args;
26644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26645 if (!SWIG_IsOK(res1)) {
26646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26647 }
26648 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26649 {
26650 PyThreadState* __tstate = wxPyBeginAllowThreads();
26651 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26652 wxPyEndAllowThreads(__tstate);
26653 if (PyErr_Occurred()) SWIG_fail;
26654 }
26655 {
26656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26657 }
26658 return resultobj;
26659 fail:
26660 return NULL;
26661 }
26662
26663
26664 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26665 PyObject *resultobj = 0;
26666 wxIdleMode arg1 ;
26667 int val1 ;
26668 int ecode1 = 0 ;
26669 PyObject * obj0 = 0 ;
26670 char * kwnames[] = {
26671 (char *) "mode", NULL
26672 };
26673
26674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26675 ecode1 = SWIG_AsVal_int(obj0, &val1);
26676 if (!SWIG_IsOK(ecode1)) {
26677 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26678 }
26679 arg1 = static_cast< wxIdleMode >(val1);
26680 {
26681 PyThreadState* __tstate = wxPyBeginAllowThreads();
26682 wxIdleEvent::SetMode(arg1);
26683 wxPyEndAllowThreads(__tstate);
26684 if (PyErr_Occurred()) SWIG_fail;
26685 }
26686 resultobj = SWIG_Py_Void();
26687 return resultobj;
26688 fail:
26689 return NULL;
26690 }
26691
26692
26693 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26694 PyObject *resultobj = 0;
26695 wxIdleMode result;
26696
26697 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26698 {
26699 PyThreadState* __tstate = wxPyBeginAllowThreads();
26700 result = (wxIdleMode)wxIdleEvent::GetMode();
26701 wxPyEndAllowThreads(__tstate);
26702 if (PyErr_Occurred()) SWIG_fail;
26703 }
26704 resultobj = SWIG_From_int(static_cast< int >(result));
26705 return resultobj;
26706 fail:
26707 return NULL;
26708 }
26709
26710
26711 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26712 PyObject *resultobj = 0;
26713 wxWindow *arg1 = (wxWindow *) 0 ;
26714 bool result;
26715 void *argp1 = 0 ;
26716 int res1 = 0 ;
26717 PyObject * obj0 = 0 ;
26718 char * kwnames[] = {
26719 (char *) "win", NULL
26720 };
26721
26722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26724 if (!SWIG_IsOK(res1)) {
26725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26726 }
26727 arg1 = reinterpret_cast< wxWindow * >(argp1);
26728 {
26729 PyThreadState* __tstate = wxPyBeginAllowThreads();
26730 result = (bool)wxIdleEvent::CanSend(arg1);
26731 wxPyEndAllowThreads(__tstate);
26732 if (PyErr_Occurred()) SWIG_fail;
26733 }
26734 {
26735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26736 }
26737 return resultobj;
26738 fail:
26739 return NULL;
26740 }
26741
26742
26743 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26744 PyObject *obj;
26745 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26746 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26747 return SWIG_Py_Void();
26748 }
26749
26750 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26751 return SWIG_Python_InitShadowInstance(args);
26752 }
26753
26754 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26755 PyObject *resultobj = 0;
26756 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26757 int arg2 = (int) 0 ;
26758 wxClipboardTextEvent *result = 0 ;
26759 int val1 ;
26760 int ecode1 = 0 ;
26761 int val2 ;
26762 int ecode2 = 0 ;
26763 PyObject * obj0 = 0 ;
26764 PyObject * obj1 = 0 ;
26765 char * kwnames[] = {
26766 (char *) "type",(char *) "winid", NULL
26767 };
26768
26769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26770 if (obj0) {
26771 ecode1 = SWIG_AsVal_int(obj0, &val1);
26772 if (!SWIG_IsOK(ecode1)) {
26773 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26774 }
26775 arg1 = static_cast< wxEventType >(val1);
26776 }
26777 if (obj1) {
26778 ecode2 = SWIG_AsVal_int(obj1, &val2);
26779 if (!SWIG_IsOK(ecode2)) {
26780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26781 }
26782 arg2 = static_cast< int >(val2);
26783 }
26784 {
26785 PyThreadState* __tstate = wxPyBeginAllowThreads();
26786 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26787 wxPyEndAllowThreads(__tstate);
26788 if (PyErr_Occurred()) SWIG_fail;
26789 }
26790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26791 return resultobj;
26792 fail:
26793 return NULL;
26794 }
26795
26796
26797 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26798 PyObject *obj;
26799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26800 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26801 return SWIG_Py_Void();
26802 }
26803
26804 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26805 return SWIG_Python_InitShadowInstance(args);
26806 }
26807
26808 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26809 PyObject *resultobj = 0;
26810 int arg1 = (int) 0 ;
26811 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26812 wxPyEvent *result = 0 ;
26813 int val1 ;
26814 int ecode1 = 0 ;
26815 int val2 ;
26816 int ecode2 = 0 ;
26817 PyObject * obj0 = 0 ;
26818 PyObject * obj1 = 0 ;
26819 char * kwnames[] = {
26820 (char *) "winid",(char *) "eventType", NULL
26821 };
26822
26823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26824 if (obj0) {
26825 ecode1 = SWIG_AsVal_int(obj0, &val1);
26826 if (!SWIG_IsOK(ecode1)) {
26827 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26828 }
26829 arg1 = static_cast< int >(val1);
26830 }
26831 if (obj1) {
26832 ecode2 = SWIG_AsVal_int(obj1, &val2);
26833 if (!SWIG_IsOK(ecode2)) {
26834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26835 }
26836 arg2 = static_cast< wxEventType >(val2);
26837 }
26838 {
26839 PyThreadState* __tstate = wxPyBeginAllowThreads();
26840 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26841 wxPyEndAllowThreads(__tstate);
26842 if (PyErr_Occurred()) SWIG_fail;
26843 }
26844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26845 return resultobj;
26846 fail:
26847 return NULL;
26848 }
26849
26850
26851 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26852 PyObject *resultobj = 0;
26853 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26854 void *argp1 = 0 ;
26855 int res1 = 0 ;
26856 PyObject *swig_obj[1] ;
26857
26858 if (!args) SWIG_fail;
26859 swig_obj[0] = args;
26860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26861 if (!SWIG_IsOK(res1)) {
26862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26863 }
26864 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26865 {
26866 PyThreadState* __tstate = wxPyBeginAllowThreads();
26867 delete arg1;
26868
26869 wxPyEndAllowThreads(__tstate);
26870 if (PyErr_Occurred()) SWIG_fail;
26871 }
26872 resultobj = SWIG_Py_Void();
26873 return resultobj;
26874 fail:
26875 return NULL;
26876 }
26877
26878
26879 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26880 PyObject *resultobj = 0;
26881 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26882 PyObject *arg2 = (PyObject *) 0 ;
26883 void *argp1 = 0 ;
26884 int res1 = 0 ;
26885 PyObject * obj0 = 0 ;
26886 PyObject * obj1 = 0 ;
26887 char * kwnames[] = {
26888 (char *) "self",(char *) "self", NULL
26889 };
26890
26891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26893 if (!SWIG_IsOK(res1)) {
26894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26895 }
26896 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26897 arg2 = obj1;
26898 {
26899 PyThreadState* __tstate = wxPyBeginAllowThreads();
26900 (arg1)->SetSelf(arg2);
26901 wxPyEndAllowThreads(__tstate);
26902 if (PyErr_Occurred()) SWIG_fail;
26903 }
26904 resultobj = SWIG_Py_Void();
26905 return resultobj;
26906 fail:
26907 return NULL;
26908 }
26909
26910
26911 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26912 PyObject *resultobj = 0;
26913 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26914 PyObject *result = 0 ;
26915 void *argp1 = 0 ;
26916 int res1 = 0 ;
26917 PyObject *swig_obj[1] ;
26918
26919 if (!args) SWIG_fail;
26920 swig_obj[0] = args;
26921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26922 if (!SWIG_IsOK(res1)) {
26923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26924 }
26925 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26926 {
26927 PyThreadState* __tstate = wxPyBeginAllowThreads();
26928 result = (PyObject *)(arg1)->GetSelf();
26929 wxPyEndAllowThreads(__tstate);
26930 if (PyErr_Occurred()) SWIG_fail;
26931 }
26932 resultobj = result;
26933 return resultobj;
26934 fail:
26935 return NULL;
26936 }
26937
26938
26939 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26940 PyObject *obj;
26941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26942 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26943 return SWIG_Py_Void();
26944 }
26945
26946 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26947 return SWIG_Python_InitShadowInstance(args);
26948 }
26949
26950 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26951 PyObject *resultobj = 0;
26952 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26953 int arg2 = (int) 0 ;
26954 wxPyCommandEvent *result = 0 ;
26955 int val1 ;
26956 int ecode1 = 0 ;
26957 int val2 ;
26958 int ecode2 = 0 ;
26959 PyObject * obj0 = 0 ;
26960 PyObject * obj1 = 0 ;
26961 char * kwnames[] = {
26962 (char *) "eventType",(char *) "id", NULL
26963 };
26964
26965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26966 if (obj0) {
26967 ecode1 = SWIG_AsVal_int(obj0, &val1);
26968 if (!SWIG_IsOK(ecode1)) {
26969 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26970 }
26971 arg1 = static_cast< wxEventType >(val1);
26972 }
26973 if (obj1) {
26974 ecode2 = SWIG_AsVal_int(obj1, &val2);
26975 if (!SWIG_IsOK(ecode2)) {
26976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26977 }
26978 arg2 = static_cast< int >(val2);
26979 }
26980 {
26981 PyThreadState* __tstate = wxPyBeginAllowThreads();
26982 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26983 wxPyEndAllowThreads(__tstate);
26984 if (PyErr_Occurred()) SWIG_fail;
26985 }
26986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26987 return resultobj;
26988 fail:
26989 return NULL;
26990 }
26991
26992
26993 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26994 PyObject *resultobj = 0;
26995 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26996 void *argp1 = 0 ;
26997 int res1 = 0 ;
26998 PyObject *swig_obj[1] ;
26999
27000 if (!args) SWIG_fail;
27001 swig_obj[0] = args;
27002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27003 if (!SWIG_IsOK(res1)) {
27004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27005 }
27006 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27007 {
27008 PyThreadState* __tstate = wxPyBeginAllowThreads();
27009 delete arg1;
27010
27011 wxPyEndAllowThreads(__tstate);
27012 if (PyErr_Occurred()) SWIG_fail;
27013 }
27014 resultobj = SWIG_Py_Void();
27015 return resultobj;
27016 fail:
27017 return NULL;
27018 }
27019
27020
27021 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27022 PyObject *resultobj = 0;
27023 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27024 PyObject *arg2 = (PyObject *) 0 ;
27025 void *argp1 = 0 ;
27026 int res1 = 0 ;
27027 PyObject * obj0 = 0 ;
27028 PyObject * obj1 = 0 ;
27029 char * kwnames[] = {
27030 (char *) "self",(char *) "self", NULL
27031 };
27032
27033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27035 if (!SWIG_IsOK(res1)) {
27036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27037 }
27038 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27039 arg2 = obj1;
27040 {
27041 PyThreadState* __tstate = wxPyBeginAllowThreads();
27042 (arg1)->SetSelf(arg2);
27043 wxPyEndAllowThreads(__tstate);
27044 if (PyErr_Occurred()) SWIG_fail;
27045 }
27046 resultobj = SWIG_Py_Void();
27047 return resultobj;
27048 fail:
27049 return NULL;
27050 }
27051
27052
27053 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27054 PyObject *resultobj = 0;
27055 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27056 PyObject *result = 0 ;
27057 void *argp1 = 0 ;
27058 int res1 = 0 ;
27059 PyObject *swig_obj[1] ;
27060
27061 if (!args) SWIG_fail;
27062 swig_obj[0] = args;
27063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27064 if (!SWIG_IsOK(res1)) {
27065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27066 }
27067 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27068 {
27069 PyThreadState* __tstate = wxPyBeginAllowThreads();
27070 result = (PyObject *)(arg1)->GetSelf();
27071 wxPyEndAllowThreads(__tstate);
27072 if (PyErr_Occurred()) SWIG_fail;
27073 }
27074 resultobj = result;
27075 return resultobj;
27076 fail:
27077 return NULL;
27078 }
27079
27080
27081 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27082 PyObject *obj;
27083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27084 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27085 return SWIG_Py_Void();
27086 }
27087
27088 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27089 return SWIG_Python_InitShadowInstance(args);
27090 }
27091
27092 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27093 PyObject *resultobj = 0;
27094 wxWindow *arg1 = (wxWindow *) 0 ;
27095 wxDateTime *arg2 = 0 ;
27096 wxEventType arg3 ;
27097 wxDateEvent *result = 0 ;
27098 void *argp1 = 0 ;
27099 int res1 = 0 ;
27100 void *argp2 = 0 ;
27101 int res2 = 0 ;
27102 int val3 ;
27103 int ecode3 = 0 ;
27104 PyObject * obj0 = 0 ;
27105 PyObject * obj1 = 0 ;
27106 PyObject * obj2 = 0 ;
27107 char * kwnames[] = {
27108 (char *) "win",(char *) "dt",(char *) "type", NULL
27109 };
27110
27111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27113 if (!SWIG_IsOK(res1)) {
27114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27115 }
27116 arg1 = reinterpret_cast< wxWindow * >(argp1);
27117 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27118 if (!SWIG_IsOK(res2)) {
27119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27120 }
27121 if (!argp2) {
27122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27123 }
27124 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27125 ecode3 = SWIG_AsVal_int(obj2, &val3);
27126 if (!SWIG_IsOK(ecode3)) {
27127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27128 }
27129 arg3 = static_cast< wxEventType >(val3);
27130 {
27131 PyThreadState* __tstate = wxPyBeginAllowThreads();
27132 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27133 wxPyEndAllowThreads(__tstate);
27134 if (PyErr_Occurred()) SWIG_fail;
27135 }
27136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27137 return resultobj;
27138 fail:
27139 return NULL;
27140 }
27141
27142
27143 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27144 PyObject *resultobj = 0;
27145 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27146 wxDateTime *result = 0 ;
27147 void *argp1 = 0 ;
27148 int res1 = 0 ;
27149 PyObject *swig_obj[1] ;
27150
27151 if (!args) SWIG_fail;
27152 swig_obj[0] = args;
27153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27154 if (!SWIG_IsOK(res1)) {
27155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27156 }
27157 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27158 {
27159 PyThreadState* __tstate = wxPyBeginAllowThreads();
27160 {
27161 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27162 result = (wxDateTime *) &_result_ref;
27163 }
27164 wxPyEndAllowThreads(__tstate);
27165 if (PyErr_Occurred()) SWIG_fail;
27166 }
27167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27168 return resultobj;
27169 fail:
27170 return NULL;
27171 }
27172
27173
27174 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27175 PyObject *resultobj = 0;
27176 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27177 wxDateTime *arg2 = 0 ;
27178 void *argp1 = 0 ;
27179 int res1 = 0 ;
27180 void *argp2 = 0 ;
27181 int res2 = 0 ;
27182 PyObject * obj0 = 0 ;
27183 PyObject * obj1 = 0 ;
27184 char * kwnames[] = {
27185 (char *) "self",(char *) "date", NULL
27186 };
27187
27188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27190 if (!SWIG_IsOK(res1)) {
27191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27192 }
27193 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27194 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27195 if (!SWIG_IsOK(res2)) {
27196 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27197 }
27198 if (!argp2) {
27199 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27200 }
27201 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27202 {
27203 PyThreadState* __tstate = wxPyBeginAllowThreads();
27204 (arg1)->SetDate((wxDateTime const &)*arg2);
27205 wxPyEndAllowThreads(__tstate);
27206 if (PyErr_Occurred()) SWIG_fail;
27207 }
27208 resultobj = SWIG_Py_Void();
27209 return resultobj;
27210 fail:
27211 return NULL;
27212 }
27213
27214
27215 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27216 PyObject *obj;
27217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27218 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27219 return SWIG_Py_Void();
27220 }
27221
27222 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27223 return SWIG_Python_InitShadowInstance(args);
27224 }
27225
27226 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27227 PyObject *resultobj = 0;
27228 wxPyApp *result = 0 ;
27229
27230 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27231 {
27232 PyThreadState* __tstate = wxPyBeginAllowThreads();
27233 result = (wxPyApp *)new_wxPyApp();
27234 wxPyEndAllowThreads(__tstate);
27235 if (PyErr_Occurred()) SWIG_fail;
27236 }
27237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27238 return resultobj;
27239 fail:
27240 return NULL;
27241 }
27242
27243
27244 SWIGINTERN PyObject *_wrap_delete_PyApp(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, SWIG_POINTER_DISOWN | 0 );
27254 if (!SWIG_IsOK(res1)) {
27255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27256 }
27257 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27258 {
27259 PyThreadState* __tstate = wxPyBeginAllowThreads();
27260 delete arg1;
27261
27262 wxPyEndAllowThreads(__tstate);
27263 if (PyErr_Occurred()) SWIG_fail;
27264 }
27265 resultobj = SWIG_Py_Void();
27266 return resultobj;
27267 fail:
27268 return NULL;
27269 }
27270
27271
27272 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27273 PyObject *resultobj = 0;
27274 wxPyApp *arg1 = (wxPyApp *) 0 ;
27275 PyObject *arg2 = (PyObject *) 0 ;
27276 PyObject *arg3 = (PyObject *) 0 ;
27277 bool arg4 ;
27278 void *argp1 = 0 ;
27279 int res1 = 0 ;
27280 bool val4 ;
27281 int ecode4 = 0 ;
27282 PyObject * obj0 = 0 ;
27283 PyObject * obj1 = 0 ;
27284 PyObject * obj2 = 0 ;
27285 PyObject * obj3 = 0 ;
27286 char * kwnames[] = {
27287 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27288 };
27289
27290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27292 if (!SWIG_IsOK(res1)) {
27293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27294 }
27295 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27296 arg2 = obj1;
27297 arg3 = obj2;
27298 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27299 if (!SWIG_IsOK(ecode4)) {
27300 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27301 }
27302 arg4 = static_cast< bool >(val4);
27303 {
27304 PyThreadState* __tstate = wxPyBeginAllowThreads();
27305 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27306 wxPyEndAllowThreads(__tstate);
27307 if (PyErr_Occurred()) SWIG_fail;
27308 }
27309 resultobj = SWIG_Py_Void();
27310 return resultobj;
27311 fail:
27312 return NULL;
27313 }
27314
27315
27316 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27317 PyObject *resultobj = 0;
27318 wxPyApp *arg1 = (wxPyApp *) 0 ;
27319 wxString result;
27320 void *argp1 = 0 ;
27321 int res1 = 0 ;
27322 PyObject *swig_obj[1] ;
27323
27324 if (!args) SWIG_fail;
27325 swig_obj[0] = args;
27326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27327 if (!SWIG_IsOK(res1)) {
27328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27329 }
27330 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27331 {
27332 PyThreadState* __tstate = wxPyBeginAllowThreads();
27333 result = ((wxPyApp const *)arg1)->GetAppName();
27334 wxPyEndAllowThreads(__tstate);
27335 if (PyErr_Occurred()) SWIG_fail;
27336 }
27337 {
27338 #if wxUSE_UNICODE
27339 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27340 #else
27341 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27342 #endif
27343 }
27344 return resultobj;
27345 fail:
27346 return NULL;
27347 }
27348
27349
27350 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27351 PyObject *resultobj = 0;
27352 wxPyApp *arg1 = (wxPyApp *) 0 ;
27353 wxString *arg2 = 0 ;
27354 void *argp1 = 0 ;
27355 int res1 = 0 ;
27356 bool temp2 = false ;
27357 PyObject * obj0 = 0 ;
27358 PyObject * obj1 = 0 ;
27359 char * kwnames[] = {
27360 (char *) "self",(char *) "name", NULL
27361 };
27362
27363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27365 if (!SWIG_IsOK(res1)) {
27366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27367 }
27368 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27369 {
27370 arg2 = wxString_in_helper(obj1);
27371 if (arg2 == NULL) SWIG_fail;
27372 temp2 = true;
27373 }
27374 {
27375 PyThreadState* __tstate = wxPyBeginAllowThreads();
27376 (arg1)->SetAppName((wxString const &)*arg2);
27377 wxPyEndAllowThreads(__tstate);
27378 if (PyErr_Occurred()) SWIG_fail;
27379 }
27380 resultobj = SWIG_Py_Void();
27381 {
27382 if (temp2)
27383 delete arg2;
27384 }
27385 return resultobj;
27386 fail:
27387 {
27388 if (temp2)
27389 delete arg2;
27390 }
27391 return NULL;
27392 }
27393
27394
27395 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27396 PyObject *resultobj = 0;
27397 wxPyApp *arg1 = (wxPyApp *) 0 ;
27398 wxString result;
27399 void *argp1 = 0 ;
27400 int res1 = 0 ;
27401 PyObject *swig_obj[1] ;
27402
27403 if (!args) SWIG_fail;
27404 swig_obj[0] = args;
27405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27406 if (!SWIG_IsOK(res1)) {
27407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27408 }
27409 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27410 {
27411 PyThreadState* __tstate = wxPyBeginAllowThreads();
27412 result = ((wxPyApp const *)arg1)->GetClassName();
27413 wxPyEndAllowThreads(__tstate);
27414 if (PyErr_Occurred()) SWIG_fail;
27415 }
27416 {
27417 #if wxUSE_UNICODE
27418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27419 #else
27420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27421 #endif
27422 }
27423 return resultobj;
27424 fail:
27425 return NULL;
27426 }
27427
27428
27429 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27430 PyObject *resultobj = 0;
27431 wxPyApp *arg1 = (wxPyApp *) 0 ;
27432 wxString *arg2 = 0 ;
27433 void *argp1 = 0 ;
27434 int res1 = 0 ;
27435 bool temp2 = false ;
27436 PyObject * obj0 = 0 ;
27437 PyObject * obj1 = 0 ;
27438 char * kwnames[] = {
27439 (char *) "self",(char *) "name", NULL
27440 };
27441
27442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27444 if (!SWIG_IsOK(res1)) {
27445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27446 }
27447 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27448 {
27449 arg2 = wxString_in_helper(obj1);
27450 if (arg2 == NULL) SWIG_fail;
27451 temp2 = true;
27452 }
27453 {
27454 PyThreadState* __tstate = wxPyBeginAllowThreads();
27455 (arg1)->SetClassName((wxString const &)*arg2);
27456 wxPyEndAllowThreads(__tstate);
27457 if (PyErr_Occurred()) SWIG_fail;
27458 }
27459 resultobj = SWIG_Py_Void();
27460 {
27461 if (temp2)
27462 delete arg2;
27463 }
27464 return resultobj;
27465 fail:
27466 {
27467 if (temp2)
27468 delete arg2;
27469 }
27470 return NULL;
27471 }
27472
27473
27474 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27475 PyObject *resultobj = 0;
27476 wxPyApp *arg1 = (wxPyApp *) 0 ;
27477 wxString *result = 0 ;
27478 void *argp1 = 0 ;
27479 int res1 = 0 ;
27480 PyObject *swig_obj[1] ;
27481
27482 if (!args) SWIG_fail;
27483 swig_obj[0] = args;
27484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27485 if (!SWIG_IsOK(res1)) {
27486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27487 }
27488 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27489 {
27490 PyThreadState* __tstate = wxPyBeginAllowThreads();
27491 {
27492 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27493 result = (wxString *) &_result_ref;
27494 }
27495 wxPyEndAllowThreads(__tstate);
27496 if (PyErr_Occurred()) SWIG_fail;
27497 }
27498 {
27499 #if wxUSE_UNICODE
27500 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27501 #else
27502 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27503 #endif
27504 }
27505 return resultobj;
27506 fail:
27507 return NULL;
27508 }
27509
27510
27511 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27512 PyObject *resultobj = 0;
27513 wxPyApp *arg1 = (wxPyApp *) 0 ;
27514 wxString *arg2 = 0 ;
27515 void *argp1 = 0 ;
27516 int res1 = 0 ;
27517 bool temp2 = false ;
27518 PyObject * obj0 = 0 ;
27519 PyObject * obj1 = 0 ;
27520 char * kwnames[] = {
27521 (char *) "self",(char *) "name", NULL
27522 };
27523
27524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27526 if (!SWIG_IsOK(res1)) {
27527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27528 }
27529 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27530 {
27531 arg2 = wxString_in_helper(obj1);
27532 if (arg2 == NULL) SWIG_fail;
27533 temp2 = true;
27534 }
27535 {
27536 PyThreadState* __tstate = wxPyBeginAllowThreads();
27537 (arg1)->SetVendorName((wxString const &)*arg2);
27538 wxPyEndAllowThreads(__tstate);
27539 if (PyErr_Occurred()) SWIG_fail;
27540 }
27541 resultobj = SWIG_Py_Void();
27542 {
27543 if (temp2)
27544 delete arg2;
27545 }
27546 return resultobj;
27547 fail:
27548 {
27549 if (temp2)
27550 delete arg2;
27551 }
27552 return NULL;
27553 }
27554
27555
27556 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27557 PyObject *resultobj = 0;
27558 wxPyApp *arg1 = (wxPyApp *) 0 ;
27559 wxAppTraits *result = 0 ;
27560 void *argp1 = 0 ;
27561 int res1 = 0 ;
27562 PyObject *swig_obj[1] ;
27563
27564 if (!args) SWIG_fail;
27565 swig_obj[0] = args;
27566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27567 if (!SWIG_IsOK(res1)) {
27568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27569 }
27570 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27571 {
27572 PyThreadState* __tstate = wxPyBeginAllowThreads();
27573 result = (wxAppTraits *)(arg1)->GetTraits();
27574 wxPyEndAllowThreads(__tstate);
27575 if (PyErr_Occurred()) SWIG_fail;
27576 }
27577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27578 return resultobj;
27579 fail:
27580 return NULL;
27581 }
27582
27583
27584 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27585 PyObject *resultobj = 0;
27586 wxPyApp *arg1 = (wxPyApp *) 0 ;
27587 void *argp1 = 0 ;
27588 int res1 = 0 ;
27589 PyObject *swig_obj[1] ;
27590
27591 if (!args) SWIG_fail;
27592 swig_obj[0] = args;
27593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27594 if (!SWIG_IsOK(res1)) {
27595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27596 }
27597 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 (arg1)->ProcessPendingEvents();
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 resultobj = SWIG_Py_Void();
27605 return resultobj;
27606 fail:
27607 return NULL;
27608 }
27609
27610
27611 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27612 PyObject *resultobj = 0;
27613 wxPyApp *arg1 = (wxPyApp *) 0 ;
27614 bool arg2 = (bool) false ;
27615 bool result;
27616 void *argp1 = 0 ;
27617 int res1 = 0 ;
27618 bool val2 ;
27619 int ecode2 = 0 ;
27620 PyObject * obj0 = 0 ;
27621 PyObject * obj1 = 0 ;
27622 char * kwnames[] = {
27623 (char *) "self",(char *) "onlyIfNeeded", NULL
27624 };
27625
27626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27628 if (!SWIG_IsOK(res1)) {
27629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27630 }
27631 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27632 if (obj1) {
27633 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27634 if (!SWIG_IsOK(ecode2)) {
27635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27636 }
27637 arg2 = static_cast< bool >(val2);
27638 }
27639 {
27640 PyThreadState* __tstate = wxPyBeginAllowThreads();
27641 result = (bool)(arg1)->Yield(arg2);
27642 wxPyEndAllowThreads(__tstate);
27643 if (PyErr_Occurred()) SWIG_fail;
27644 }
27645 {
27646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27647 }
27648 return resultobj;
27649 fail:
27650 return NULL;
27651 }
27652
27653
27654 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27655 PyObject *resultobj = 0;
27656 wxPyApp *arg1 = (wxPyApp *) 0 ;
27657 void *argp1 = 0 ;
27658 int res1 = 0 ;
27659 PyObject *swig_obj[1] ;
27660
27661 if (!args) SWIG_fail;
27662 swig_obj[0] = args;
27663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27664 if (!SWIG_IsOK(res1)) {
27665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27666 }
27667 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27668 {
27669 PyThreadState* __tstate = wxPyBeginAllowThreads();
27670 (arg1)->WakeUpIdle();
27671 wxPyEndAllowThreads(__tstate);
27672 if (PyErr_Occurred()) SWIG_fail;
27673 }
27674 resultobj = SWIG_Py_Void();
27675 return resultobj;
27676 fail:
27677 return NULL;
27678 }
27679
27680
27681 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27682 PyObject *resultobj = 0;
27683 bool result;
27684
27685 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27686 {
27687 PyThreadState* __tstate = wxPyBeginAllowThreads();
27688 result = (bool)wxPyApp::IsMainLoopRunning();
27689 wxPyEndAllowThreads(__tstate);
27690 if (PyErr_Occurred()) SWIG_fail;
27691 }
27692 {
27693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27694 }
27695 return resultobj;
27696 fail:
27697 return NULL;
27698 }
27699
27700
27701 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27702 PyObject *resultobj = 0;
27703 wxPyApp *arg1 = (wxPyApp *) 0 ;
27704 int result;
27705 void *argp1 = 0 ;
27706 int res1 = 0 ;
27707 PyObject *swig_obj[1] ;
27708
27709 if (!args) SWIG_fail;
27710 swig_obj[0] = args;
27711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27712 if (!SWIG_IsOK(res1)) {
27713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27714 }
27715 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27716 {
27717 PyThreadState* __tstate = wxPyBeginAllowThreads();
27718 result = (int)(arg1)->MainLoop();
27719 wxPyEndAllowThreads(__tstate);
27720 if (PyErr_Occurred()) SWIG_fail;
27721 }
27722 resultobj = SWIG_From_int(static_cast< int >(result));
27723 return resultobj;
27724 fail:
27725 return NULL;
27726 }
27727
27728
27729 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27730 PyObject *resultobj = 0;
27731 wxPyApp *arg1 = (wxPyApp *) 0 ;
27732 void *argp1 = 0 ;
27733 int res1 = 0 ;
27734 PyObject *swig_obj[1] ;
27735
27736 if (!args) SWIG_fail;
27737 swig_obj[0] = args;
27738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27739 if (!SWIG_IsOK(res1)) {
27740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27741 }
27742 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27743 {
27744 PyThreadState* __tstate = wxPyBeginAllowThreads();
27745 (arg1)->Exit();
27746 wxPyEndAllowThreads(__tstate);
27747 if (PyErr_Occurred()) SWIG_fail;
27748 }
27749 resultobj = SWIG_Py_Void();
27750 return resultobj;
27751 fail:
27752 return NULL;
27753 }
27754
27755
27756 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27757 PyObject *resultobj = 0;
27758 wxPyApp *arg1 = (wxPyApp *) 0 ;
27759 wxLayoutDirection result;
27760 void *argp1 = 0 ;
27761 int res1 = 0 ;
27762 PyObject *swig_obj[1] ;
27763
27764 if (!args) SWIG_fail;
27765 swig_obj[0] = args;
27766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27767 if (!SWIG_IsOK(res1)) {
27768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27769 }
27770 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27771 {
27772 PyThreadState* __tstate = wxPyBeginAllowThreads();
27773 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
27774 wxPyEndAllowThreads(__tstate);
27775 if (PyErr_Occurred()) SWIG_fail;
27776 }
27777 resultobj = SWIG_From_int(static_cast< int >(result));
27778 return resultobj;
27779 fail:
27780 return NULL;
27781 }
27782
27783
27784 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27785 PyObject *resultobj = 0;
27786 wxPyApp *arg1 = (wxPyApp *) 0 ;
27787 void *argp1 = 0 ;
27788 int res1 = 0 ;
27789 PyObject *swig_obj[1] ;
27790
27791 if (!args) SWIG_fail;
27792 swig_obj[0] = args;
27793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27794 if (!SWIG_IsOK(res1)) {
27795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27796 }
27797 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27798 {
27799 PyThreadState* __tstate = wxPyBeginAllowThreads();
27800 (arg1)->ExitMainLoop();
27801 wxPyEndAllowThreads(__tstate);
27802 if (PyErr_Occurred()) SWIG_fail;
27803 }
27804 resultobj = SWIG_Py_Void();
27805 return resultobj;
27806 fail:
27807 return NULL;
27808 }
27809
27810
27811 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27812 PyObject *resultobj = 0;
27813 wxPyApp *arg1 = (wxPyApp *) 0 ;
27814 bool result;
27815 void *argp1 = 0 ;
27816 int res1 = 0 ;
27817 PyObject *swig_obj[1] ;
27818
27819 if (!args) SWIG_fail;
27820 swig_obj[0] = args;
27821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27822 if (!SWIG_IsOK(res1)) {
27823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27824 }
27825 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27826 {
27827 PyThreadState* __tstate = wxPyBeginAllowThreads();
27828 result = (bool)(arg1)->Pending();
27829 wxPyEndAllowThreads(__tstate);
27830 if (PyErr_Occurred()) SWIG_fail;
27831 }
27832 {
27833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27834 }
27835 return resultobj;
27836 fail:
27837 return NULL;
27838 }
27839
27840
27841 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27842 PyObject *resultobj = 0;
27843 wxPyApp *arg1 = (wxPyApp *) 0 ;
27844 bool result;
27845 void *argp1 = 0 ;
27846 int res1 = 0 ;
27847 PyObject *swig_obj[1] ;
27848
27849 if (!args) SWIG_fail;
27850 swig_obj[0] = args;
27851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27852 if (!SWIG_IsOK(res1)) {
27853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27854 }
27855 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27856 {
27857 PyThreadState* __tstate = wxPyBeginAllowThreads();
27858 result = (bool)(arg1)->Dispatch();
27859 wxPyEndAllowThreads(__tstate);
27860 if (PyErr_Occurred()) SWIG_fail;
27861 }
27862 {
27863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27864 }
27865 return resultobj;
27866 fail:
27867 return NULL;
27868 }
27869
27870
27871 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27872 PyObject *resultobj = 0;
27873 wxPyApp *arg1 = (wxPyApp *) 0 ;
27874 bool result;
27875 void *argp1 = 0 ;
27876 int res1 = 0 ;
27877 PyObject *swig_obj[1] ;
27878
27879 if (!args) SWIG_fail;
27880 swig_obj[0] = args;
27881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27882 if (!SWIG_IsOK(res1)) {
27883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27884 }
27885 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27886 {
27887 PyThreadState* __tstate = wxPyBeginAllowThreads();
27888 result = (bool)(arg1)->ProcessIdle();
27889 wxPyEndAllowThreads(__tstate);
27890 if (PyErr_Occurred()) SWIG_fail;
27891 }
27892 {
27893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27894 }
27895 return resultobj;
27896 fail:
27897 return NULL;
27898 }
27899
27900
27901 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27902 PyObject *resultobj = 0;
27903 wxPyApp *arg1 = (wxPyApp *) 0 ;
27904 wxWindow *arg2 = (wxWindow *) 0 ;
27905 wxIdleEvent *arg3 = 0 ;
27906 bool result;
27907 void *argp1 = 0 ;
27908 int res1 = 0 ;
27909 void *argp2 = 0 ;
27910 int res2 = 0 ;
27911 void *argp3 = 0 ;
27912 int res3 = 0 ;
27913 PyObject * obj0 = 0 ;
27914 PyObject * obj1 = 0 ;
27915 PyObject * obj2 = 0 ;
27916 char * kwnames[] = {
27917 (char *) "self",(char *) "win",(char *) "event", NULL
27918 };
27919
27920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27922 if (!SWIG_IsOK(res1)) {
27923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27924 }
27925 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27926 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27927 if (!SWIG_IsOK(res2)) {
27928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27929 }
27930 arg2 = reinterpret_cast< wxWindow * >(argp2);
27931 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27932 if (!SWIG_IsOK(res3)) {
27933 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27934 }
27935 if (!argp3) {
27936 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27937 }
27938 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27939 {
27940 PyThreadState* __tstate = wxPyBeginAllowThreads();
27941 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27942 wxPyEndAllowThreads(__tstate);
27943 if (PyErr_Occurred()) SWIG_fail;
27944 }
27945 {
27946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27947 }
27948 return resultobj;
27949 fail:
27950 return NULL;
27951 }
27952
27953
27954 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27955 PyObject *resultobj = 0;
27956 wxPyApp *arg1 = (wxPyApp *) 0 ;
27957 bool result;
27958 void *argp1 = 0 ;
27959 int res1 = 0 ;
27960 PyObject *swig_obj[1] ;
27961
27962 if (!args) SWIG_fail;
27963 swig_obj[0] = args;
27964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27965 if (!SWIG_IsOK(res1)) {
27966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27967 }
27968 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27969 {
27970 PyThreadState* __tstate = wxPyBeginAllowThreads();
27971 result = (bool)((wxPyApp const *)arg1)->IsActive();
27972 wxPyEndAllowThreads(__tstate);
27973 if (PyErr_Occurred()) SWIG_fail;
27974 }
27975 {
27976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27977 }
27978 return resultobj;
27979 fail:
27980 return NULL;
27981 }
27982
27983
27984 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27985 PyObject *resultobj = 0;
27986 wxPyApp *arg1 = (wxPyApp *) 0 ;
27987 wxWindow *arg2 = (wxWindow *) 0 ;
27988 void *argp1 = 0 ;
27989 int res1 = 0 ;
27990 void *argp2 = 0 ;
27991 int res2 = 0 ;
27992 PyObject * obj0 = 0 ;
27993 PyObject * obj1 = 0 ;
27994 char * kwnames[] = {
27995 (char *) "self",(char *) "win", NULL
27996 };
27997
27998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28000 if (!SWIG_IsOK(res1)) {
28001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28002 }
28003 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28004 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28005 if (!SWIG_IsOK(res2)) {
28006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28007 }
28008 arg2 = reinterpret_cast< wxWindow * >(argp2);
28009 {
28010 PyThreadState* __tstate = wxPyBeginAllowThreads();
28011 (arg1)->SetTopWindow(arg2);
28012 wxPyEndAllowThreads(__tstate);
28013 if (PyErr_Occurred()) SWIG_fail;
28014 }
28015 resultobj = SWIG_Py_Void();
28016 return resultobj;
28017 fail:
28018 return NULL;
28019 }
28020
28021
28022 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28023 PyObject *resultobj = 0;
28024 wxPyApp *arg1 = (wxPyApp *) 0 ;
28025 wxWindow *result = 0 ;
28026 void *argp1 = 0 ;
28027 int res1 = 0 ;
28028 PyObject *swig_obj[1] ;
28029
28030 if (!args) SWIG_fail;
28031 swig_obj[0] = args;
28032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28033 if (!SWIG_IsOK(res1)) {
28034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28035 }
28036 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28037 {
28038 PyThreadState* __tstate = wxPyBeginAllowThreads();
28039 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28040 wxPyEndAllowThreads(__tstate);
28041 if (PyErr_Occurred()) SWIG_fail;
28042 }
28043 {
28044 resultobj = wxPyMake_wxObject(result, (bool)0);
28045 }
28046 return resultobj;
28047 fail:
28048 return NULL;
28049 }
28050
28051
28052 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28053 PyObject *resultobj = 0;
28054 wxPyApp *arg1 = (wxPyApp *) 0 ;
28055 bool arg2 ;
28056 void *argp1 = 0 ;
28057 int res1 = 0 ;
28058 bool val2 ;
28059 int ecode2 = 0 ;
28060 PyObject * obj0 = 0 ;
28061 PyObject * obj1 = 0 ;
28062 char * kwnames[] = {
28063 (char *) "self",(char *) "flag", NULL
28064 };
28065
28066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28068 if (!SWIG_IsOK(res1)) {
28069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28070 }
28071 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28072 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28073 if (!SWIG_IsOK(ecode2)) {
28074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28075 }
28076 arg2 = static_cast< bool >(val2);
28077 {
28078 PyThreadState* __tstate = wxPyBeginAllowThreads();
28079 (arg1)->SetExitOnFrameDelete(arg2);
28080 wxPyEndAllowThreads(__tstate);
28081 if (PyErr_Occurred()) SWIG_fail;
28082 }
28083 resultobj = SWIG_Py_Void();
28084 return resultobj;
28085 fail:
28086 return NULL;
28087 }
28088
28089
28090 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28091 PyObject *resultobj = 0;
28092 wxPyApp *arg1 = (wxPyApp *) 0 ;
28093 bool result;
28094 void *argp1 = 0 ;
28095 int res1 = 0 ;
28096 PyObject *swig_obj[1] ;
28097
28098 if (!args) SWIG_fail;
28099 swig_obj[0] = args;
28100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28101 if (!SWIG_IsOK(res1)) {
28102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28103 }
28104 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28105 {
28106 PyThreadState* __tstate = wxPyBeginAllowThreads();
28107 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28108 wxPyEndAllowThreads(__tstate);
28109 if (PyErr_Occurred()) SWIG_fail;
28110 }
28111 {
28112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28113 }
28114 return resultobj;
28115 fail:
28116 return NULL;
28117 }
28118
28119
28120 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28121 PyObject *resultobj = 0;
28122 wxPyApp *arg1 = (wxPyApp *) 0 ;
28123 bool arg2 ;
28124 void *argp1 = 0 ;
28125 int res1 = 0 ;
28126 bool val2 ;
28127 int ecode2 = 0 ;
28128 PyObject * obj0 = 0 ;
28129 PyObject * obj1 = 0 ;
28130 char * kwnames[] = {
28131 (char *) "self",(char *) "flag", NULL
28132 };
28133
28134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28136 if (!SWIG_IsOK(res1)) {
28137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28138 }
28139 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28140 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28141 if (!SWIG_IsOK(ecode2)) {
28142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28143 }
28144 arg2 = static_cast< bool >(val2);
28145 {
28146 PyThreadState* __tstate = wxPyBeginAllowThreads();
28147 (arg1)->SetUseBestVisual(arg2);
28148 wxPyEndAllowThreads(__tstate);
28149 if (PyErr_Occurred()) SWIG_fail;
28150 }
28151 resultobj = SWIG_Py_Void();
28152 return resultobj;
28153 fail:
28154 return NULL;
28155 }
28156
28157
28158 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28159 PyObject *resultobj = 0;
28160 wxPyApp *arg1 = (wxPyApp *) 0 ;
28161 bool result;
28162 void *argp1 = 0 ;
28163 int res1 = 0 ;
28164 PyObject *swig_obj[1] ;
28165
28166 if (!args) SWIG_fail;
28167 swig_obj[0] = args;
28168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28169 if (!SWIG_IsOK(res1)) {
28170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28171 }
28172 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28173 {
28174 PyThreadState* __tstate = wxPyBeginAllowThreads();
28175 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
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_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28189 PyObject *resultobj = 0;
28190 wxPyApp *arg1 = (wxPyApp *) 0 ;
28191 int arg2 ;
28192 void *argp1 = 0 ;
28193 int res1 = 0 ;
28194 int val2 ;
28195 int ecode2 = 0 ;
28196 PyObject * obj0 = 0 ;
28197 PyObject * obj1 = 0 ;
28198 char * kwnames[] = {
28199 (char *) "self",(char *) "mode", NULL
28200 };
28201
28202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28204 if (!SWIG_IsOK(res1)) {
28205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28206 }
28207 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28208 ecode2 = SWIG_AsVal_int(obj1, &val2);
28209 if (!SWIG_IsOK(ecode2)) {
28210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28211 }
28212 arg2 = static_cast< int >(val2);
28213 {
28214 PyThreadState* __tstate = wxPyBeginAllowThreads();
28215 (arg1)->SetPrintMode(arg2);
28216 wxPyEndAllowThreads(__tstate);
28217 if (PyErr_Occurred()) SWIG_fail;
28218 }
28219 resultobj = SWIG_Py_Void();
28220 return resultobj;
28221 fail:
28222 return NULL;
28223 }
28224
28225
28226 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28227 PyObject *resultobj = 0;
28228 wxPyApp *arg1 = (wxPyApp *) 0 ;
28229 int result;
28230 void *argp1 = 0 ;
28231 int res1 = 0 ;
28232 PyObject *swig_obj[1] ;
28233
28234 if (!args) SWIG_fail;
28235 swig_obj[0] = args;
28236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28237 if (!SWIG_IsOK(res1)) {
28238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28239 }
28240 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28241 {
28242 PyThreadState* __tstate = wxPyBeginAllowThreads();
28243 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28244 wxPyEndAllowThreads(__tstate);
28245 if (PyErr_Occurred()) SWIG_fail;
28246 }
28247 resultobj = SWIG_From_int(static_cast< int >(result));
28248 return resultobj;
28249 fail:
28250 return NULL;
28251 }
28252
28253
28254 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28255 PyObject *resultobj = 0;
28256 wxPyApp *arg1 = (wxPyApp *) 0 ;
28257 int arg2 ;
28258 void *argp1 = 0 ;
28259 int res1 = 0 ;
28260 int val2 ;
28261 int ecode2 = 0 ;
28262 PyObject * obj0 = 0 ;
28263 PyObject * obj1 = 0 ;
28264 char * kwnames[] = {
28265 (char *) "self",(char *) "mode", NULL
28266 };
28267
28268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28270 if (!SWIG_IsOK(res1)) {
28271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28272 }
28273 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28274 ecode2 = SWIG_AsVal_int(obj1, &val2);
28275 if (!SWIG_IsOK(ecode2)) {
28276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28277 }
28278 arg2 = static_cast< int >(val2);
28279 {
28280 PyThreadState* __tstate = wxPyBeginAllowThreads();
28281 (arg1)->SetAssertMode(arg2);
28282 wxPyEndAllowThreads(__tstate);
28283 if (PyErr_Occurred()) SWIG_fail;
28284 }
28285 resultobj = SWIG_Py_Void();
28286 return resultobj;
28287 fail:
28288 return NULL;
28289 }
28290
28291
28292 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28293 PyObject *resultobj = 0;
28294 wxPyApp *arg1 = (wxPyApp *) 0 ;
28295 int result;
28296 void *argp1 = 0 ;
28297 int res1 = 0 ;
28298 PyObject *swig_obj[1] ;
28299
28300 if (!args) SWIG_fail;
28301 swig_obj[0] = args;
28302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28303 if (!SWIG_IsOK(res1)) {
28304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28305 }
28306 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28307 {
28308 PyThreadState* __tstate = wxPyBeginAllowThreads();
28309 result = (int)(arg1)->GetAssertMode();
28310 wxPyEndAllowThreads(__tstate);
28311 if (PyErr_Occurred()) SWIG_fail;
28312 }
28313 resultobj = SWIG_From_int(static_cast< int >(result));
28314 return resultobj;
28315 fail:
28316 return NULL;
28317 }
28318
28319
28320 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28321 PyObject *resultobj = 0;
28322 bool result;
28323
28324 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28325 {
28326 PyThreadState* __tstate = wxPyBeginAllowThreads();
28327 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28328 wxPyEndAllowThreads(__tstate);
28329 if (PyErr_Occurred()) SWIG_fail;
28330 }
28331 {
28332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28333 }
28334 return resultobj;
28335 fail:
28336 return NULL;
28337 }
28338
28339
28340 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28341 PyObject *resultobj = 0;
28342 long result;
28343
28344 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28345 {
28346 PyThreadState* __tstate = wxPyBeginAllowThreads();
28347 result = (long)wxPyApp::GetMacAboutMenuItemId();
28348 wxPyEndAllowThreads(__tstate);
28349 if (PyErr_Occurred()) SWIG_fail;
28350 }
28351 resultobj = SWIG_From_long(static_cast< long >(result));
28352 return resultobj;
28353 fail:
28354 return NULL;
28355 }
28356
28357
28358 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28359 PyObject *resultobj = 0;
28360 long result;
28361
28362 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28363 {
28364 PyThreadState* __tstate = wxPyBeginAllowThreads();
28365 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28366 wxPyEndAllowThreads(__tstate);
28367 if (PyErr_Occurred()) SWIG_fail;
28368 }
28369 resultobj = SWIG_From_long(static_cast< long >(result));
28370 return resultobj;
28371 fail:
28372 return NULL;
28373 }
28374
28375
28376 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28377 PyObject *resultobj = 0;
28378 long result;
28379
28380 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28381 {
28382 PyThreadState* __tstate = wxPyBeginAllowThreads();
28383 result = (long)wxPyApp::GetMacExitMenuItemId();
28384 wxPyEndAllowThreads(__tstate);
28385 if (PyErr_Occurred()) SWIG_fail;
28386 }
28387 resultobj = SWIG_From_long(static_cast< long >(result));
28388 return resultobj;
28389 fail:
28390 return NULL;
28391 }
28392
28393
28394 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28395 PyObject *resultobj = 0;
28396 wxString result;
28397
28398 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28399 {
28400 PyThreadState* __tstate = wxPyBeginAllowThreads();
28401 result = wxPyApp::GetMacHelpMenuTitleName();
28402 wxPyEndAllowThreads(__tstate);
28403 if (PyErr_Occurred()) SWIG_fail;
28404 }
28405 {
28406 #if wxUSE_UNICODE
28407 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28408 #else
28409 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28410 #endif
28411 }
28412 return resultobj;
28413 fail:
28414 return NULL;
28415 }
28416
28417
28418 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28419 PyObject *resultobj = 0;
28420 bool arg1 ;
28421 bool val1 ;
28422 int ecode1 = 0 ;
28423 PyObject * obj0 = 0 ;
28424 char * kwnames[] = {
28425 (char *) "val", NULL
28426 };
28427
28428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28429 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28430 if (!SWIG_IsOK(ecode1)) {
28431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28432 }
28433 arg1 = static_cast< bool >(val1);
28434 {
28435 PyThreadState* __tstate = wxPyBeginAllowThreads();
28436 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
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_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28448 PyObject *resultobj = 0;
28449 long arg1 ;
28450 long val1 ;
28451 int ecode1 = 0 ;
28452 PyObject * obj0 = 0 ;
28453 char * kwnames[] = {
28454 (char *) "val", NULL
28455 };
28456
28457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28458 ecode1 = SWIG_AsVal_long(obj0, &val1);
28459 if (!SWIG_IsOK(ecode1)) {
28460 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28461 }
28462 arg1 = static_cast< long >(val1);
28463 {
28464 PyThreadState* __tstate = wxPyBeginAllowThreads();
28465 wxPyApp::SetMacAboutMenuItemId(arg1);
28466 wxPyEndAllowThreads(__tstate);
28467 if (PyErr_Occurred()) SWIG_fail;
28468 }
28469 resultobj = SWIG_Py_Void();
28470 return resultobj;
28471 fail:
28472 return NULL;
28473 }
28474
28475
28476 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28477 PyObject *resultobj = 0;
28478 long arg1 ;
28479 long val1 ;
28480 int ecode1 = 0 ;
28481 PyObject * obj0 = 0 ;
28482 char * kwnames[] = {
28483 (char *) "val", NULL
28484 };
28485
28486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28487 ecode1 = SWIG_AsVal_long(obj0, &val1);
28488 if (!SWIG_IsOK(ecode1)) {
28489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28490 }
28491 arg1 = static_cast< long >(val1);
28492 {
28493 PyThreadState* __tstate = wxPyBeginAllowThreads();
28494 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28495 wxPyEndAllowThreads(__tstate);
28496 if (PyErr_Occurred()) SWIG_fail;
28497 }
28498 resultobj = SWIG_Py_Void();
28499 return resultobj;
28500 fail:
28501 return NULL;
28502 }
28503
28504
28505 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28506 PyObject *resultobj = 0;
28507 long arg1 ;
28508 long val1 ;
28509 int ecode1 = 0 ;
28510 PyObject * obj0 = 0 ;
28511 char * kwnames[] = {
28512 (char *) "val", NULL
28513 };
28514
28515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28516 ecode1 = SWIG_AsVal_long(obj0, &val1);
28517 if (!SWIG_IsOK(ecode1)) {
28518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28519 }
28520 arg1 = static_cast< long >(val1);
28521 {
28522 PyThreadState* __tstate = wxPyBeginAllowThreads();
28523 wxPyApp::SetMacExitMenuItemId(arg1);
28524 wxPyEndAllowThreads(__tstate);
28525 if (PyErr_Occurred()) SWIG_fail;
28526 }
28527 resultobj = SWIG_Py_Void();
28528 return resultobj;
28529 fail:
28530 return NULL;
28531 }
28532
28533
28534 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28535 PyObject *resultobj = 0;
28536 wxString *arg1 = 0 ;
28537 bool temp1 = false ;
28538 PyObject * obj0 = 0 ;
28539 char * kwnames[] = {
28540 (char *) "val", NULL
28541 };
28542
28543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28544 {
28545 arg1 = wxString_in_helper(obj0);
28546 if (arg1 == NULL) SWIG_fail;
28547 temp1 = true;
28548 }
28549 {
28550 PyThreadState* __tstate = wxPyBeginAllowThreads();
28551 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28552 wxPyEndAllowThreads(__tstate);
28553 if (PyErr_Occurred()) SWIG_fail;
28554 }
28555 resultobj = SWIG_Py_Void();
28556 {
28557 if (temp1)
28558 delete arg1;
28559 }
28560 return resultobj;
28561 fail:
28562 {
28563 if (temp1)
28564 delete arg1;
28565 }
28566 return NULL;
28567 }
28568
28569
28570 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28571 PyObject *resultobj = 0;
28572 wxPyApp *arg1 = (wxPyApp *) 0 ;
28573 void *argp1 = 0 ;
28574 int res1 = 0 ;
28575 PyObject *swig_obj[1] ;
28576
28577 if (!args) SWIG_fail;
28578 swig_obj[0] = args;
28579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28580 if (!SWIG_IsOK(res1)) {
28581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28582 }
28583 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28584 {
28585 PyThreadState* __tstate = wxPyBeginAllowThreads();
28586 (arg1)->_BootstrapApp();
28587 wxPyEndAllowThreads(__tstate);
28588 if (PyErr_Occurred()) SWIG_fail;
28589 }
28590 resultobj = SWIG_Py_Void();
28591 return resultobj;
28592 fail:
28593 return NULL;
28594 }
28595
28596
28597 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28598 PyObject *resultobj = 0;
28599 int result;
28600
28601 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28602 {
28603 PyThreadState* __tstate = wxPyBeginAllowThreads();
28604 result = (int)wxPyApp::GetComCtl32Version();
28605 wxPyEndAllowThreads(__tstate);
28606 if (PyErr_Occurred()) SWIG_fail;
28607 }
28608 resultobj = SWIG_From_int(static_cast< int >(result));
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28616 PyObject *resultobj = 0;
28617 bool result;
28618
28619 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
28620 {
28621 PyThreadState* __tstate = wxPyBeginAllowThreads();
28622 result = (bool)wxPyApp_IsDisplayAvailable();
28623 wxPyEndAllowThreads(__tstate);
28624 if (PyErr_Occurred()) SWIG_fail;
28625 }
28626 {
28627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28628 }
28629 return resultobj;
28630 fail:
28631 return NULL;
28632 }
28633
28634
28635 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28636 PyObject *obj;
28637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28638 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28639 return SWIG_Py_Void();
28640 }
28641
28642 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28643 return SWIG_Python_InitShadowInstance(args);
28644 }
28645
28646 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28647 PyObject *resultobj = 0;
28648
28649 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28650 {
28651 PyThreadState* __tstate = wxPyBeginAllowThreads();
28652 wxExit();
28653 wxPyEndAllowThreads(__tstate);
28654 if (PyErr_Occurred()) SWIG_fail;
28655 }
28656 resultobj = SWIG_Py_Void();
28657 return resultobj;
28658 fail:
28659 return NULL;
28660 }
28661
28662
28663 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28664 PyObject *resultobj = 0;
28665 bool result;
28666
28667 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28668 {
28669 PyThreadState* __tstate = wxPyBeginAllowThreads();
28670 result = (bool)wxYield();
28671 wxPyEndAllowThreads(__tstate);
28672 if (PyErr_Occurred()) SWIG_fail;
28673 }
28674 {
28675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28676 }
28677 return resultobj;
28678 fail:
28679 return NULL;
28680 }
28681
28682
28683 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28684 PyObject *resultobj = 0;
28685 bool result;
28686
28687 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28688 {
28689 PyThreadState* __tstate = wxPyBeginAllowThreads();
28690 result = (bool)wxYieldIfNeeded();
28691 wxPyEndAllowThreads(__tstate);
28692 if (PyErr_Occurred()) SWIG_fail;
28693 }
28694 {
28695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28696 }
28697 return resultobj;
28698 fail:
28699 return NULL;
28700 }
28701
28702
28703 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28704 PyObject *resultobj = 0;
28705 wxWindow *arg1 = (wxWindow *) NULL ;
28706 bool arg2 = (bool) false ;
28707 bool result;
28708 void *argp1 = 0 ;
28709 int res1 = 0 ;
28710 bool val2 ;
28711 int ecode2 = 0 ;
28712 PyObject * obj0 = 0 ;
28713 PyObject * obj1 = 0 ;
28714 char * kwnames[] = {
28715 (char *) "win",(char *) "onlyIfNeeded", NULL
28716 };
28717
28718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28719 if (obj0) {
28720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28721 if (!SWIG_IsOK(res1)) {
28722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28723 }
28724 arg1 = reinterpret_cast< wxWindow * >(argp1);
28725 }
28726 if (obj1) {
28727 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28728 if (!SWIG_IsOK(ecode2)) {
28729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28730 }
28731 arg2 = static_cast< bool >(val2);
28732 }
28733 {
28734 PyThreadState* __tstate = wxPyBeginAllowThreads();
28735 result = (bool)wxSafeYield(arg1,arg2);
28736 wxPyEndAllowThreads(__tstate);
28737 if (PyErr_Occurred()) SWIG_fail;
28738 }
28739 {
28740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28741 }
28742 return resultobj;
28743 fail:
28744 return NULL;
28745 }
28746
28747
28748 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28749 PyObject *resultobj = 0;
28750
28751 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28752 {
28753 PyThreadState* __tstate = wxPyBeginAllowThreads();
28754 wxWakeUpIdle();
28755 wxPyEndAllowThreads(__tstate);
28756 if (PyErr_Occurred()) SWIG_fail;
28757 }
28758 resultobj = SWIG_Py_Void();
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28766 PyObject *resultobj = 0;
28767 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28768 wxEvent *arg2 = 0 ;
28769 void *argp1 = 0 ;
28770 int res1 = 0 ;
28771 void *argp2 = 0 ;
28772 int res2 = 0 ;
28773 PyObject * obj0 = 0 ;
28774 PyObject * obj1 = 0 ;
28775 char * kwnames[] = {
28776 (char *) "dest",(char *) "event", NULL
28777 };
28778
28779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28781 if (!SWIG_IsOK(res1)) {
28782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28783 }
28784 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28785 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28786 if (!SWIG_IsOK(res2)) {
28787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28788 }
28789 if (!argp2) {
28790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28791 }
28792 arg2 = reinterpret_cast< wxEvent * >(argp2);
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 wxPostEvent(arg1,*arg2);
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 resultobj = SWIG_Py_Void();
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28807 PyObject *resultobj = 0;
28808
28809 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 wxApp_CleanUp();
28813 wxPyEndAllowThreads(__tstate);
28814 if (PyErr_Occurred()) SWIG_fail;
28815 }
28816 resultobj = SWIG_Py_Void();
28817 return resultobj;
28818 fail:
28819 return NULL;
28820 }
28821
28822
28823 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28824 PyObject *resultobj = 0;
28825 wxPyApp *result = 0 ;
28826
28827 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28828 {
28829 PyThreadState* __tstate = wxPyBeginAllowThreads();
28830 result = (wxPyApp *)wxPyGetApp();
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 {
28835 resultobj = wxPyMake_wxObject(result, 0);
28836 }
28837 return resultobj;
28838 fail:
28839 return NULL;
28840 }
28841
28842
28843 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28844 PyObject *resultobj = 0;
28845 char *arg1 = (char *) 0 ;
28846 int res1 ;
28847 char *buf1 = 0 ;
28848 int alloc1 = 0 ;
28849 PyObject * obj0 = 0 ;
28850 char * kwnames[] = {
28851 (char *) "encoding", NULL
28852 };
28853
28854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28855 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28856 if (!SWIG_IsOK(res1)) {
28857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28858 }
28859 arg1 = buf1;
28860 {
28861 PyThreadState* __tstate = wxPyBeginAllowThreads();
28862 wxSetDefaultPyEncoding((char const *)arg1);
28863 wxPyEndAllowThreads(__tstate);
28864 if (PyErr_Occurred()) SWIG_fail;
28865 }
28866 resultobj = SWIG_Py_Void();
28867 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28868 return resultobj;
28869 fail:
28870 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28871 return NULL;
28872 }
28873
28874
28875 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28876 PyObject *resultobj = 0;
28877 char *result = 0 ;
28878
28879 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28880 {
28881 PyThreadState* __tstate = wxPyBeginAllowThreads();
28882 result = (char *)wxGetDefaultPyEncoding();
28883 wxPyEndAllowThreads(__tstate);
28884 if (PyErr_Occurred()) SWIG_fail;
28885 }
28886 resultobj = SWIG_FromCharPtr(result);
28887 return resultobj;
28888 fail:
28889 return NULL;
28890 }
28891
28892
28893 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28894 PyObject *resultobj = 0;
28895 wxEventLoop *result = 0 ;
28896
28897 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28898 {
28899 PyThreadState* __tstate = wxPyBeginAllowThreads();
28900 result = (wxEventLoop *)new wxEventLoop();
28901 wxPyEndAllowThreads(__tstate);
28902 if (PyErr_Occurred()) SWIG_fail;
28903 }
28904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28905 return resultobj;
28906 fail:
28907 return NULL;
28908 }
28909
28910
28911 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28912 PyObject *resultobj = 0;
28913 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28914 void *argp1 = 0 ;
28915 int res1 = 0 ;
28916 PyObject *swig_obj[1] ;
28917
28918 if (!args) SWIG_fail;
28919 swig_obj[0] = args;
28920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28921 if (!SWIG_IsOK(res1)) {
28922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28923 }
28924 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28925 {
28926 PyThreadState* __tstate = wxPyBeginAllowThreads();
28927 delete arg1;
28928
28929 wxPyEndAllowThreads(__tstate);
28930 if (PyErr_Occurred()) SWIG_fail;
28931 }
28932 resultobj = SWIG_Py_Void();
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28940 PyObject *resultobj = 0;
28941 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28942 int result;
28943 void *argp1 = 0 ;
28944 int res1 = 0 ;
28945 PyObject *swig_obj[1] ;
28946
28947 if (!args) SWIG_fail;
28948 swig_obj[0] = args;
28949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28950 if (!SWIG_IsOK(res1)) {
28951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28952 }
28953 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28954 {
28955 PyThreadState* __tstate = wxPyBeginAllowThreads();
28956 result = (int)(arg1)->Run();
28957 wxPyEndAllowThreads(__tstate);
28958 if (PyErr_Occurred()) SWIG_fail;
28959 }
28960 resultobj = SWIG_From_int(static_cast< int >(result));
28961 return resultobj;
28962 fail:
28963 return NULL;
28964 }
28965
28966
28967 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28968 PyObject *resultobj = 0;
28969 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28970 int arg2 = (int) 0 ;
28971 void *argp1 = 0 ;
28972 int res1 = 0 ;
28973 int val2 ;
28974 int ecode2 = 0 ;
28975 PyObject * obj0 = 0 ;
28976 PyObject * obj1 = 0 ;
28977 char * kwnames[] = {
28978 (char *) "self",(char *) "rc", NULL
28979 };
28980
28981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28983 if (!SWIG_IsOK(res1)) {
28984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28985 }
28986 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28987 if (obj1) {
28988 ecode2 = SWIG_AsVal_int(obj1, &val2);
28989 if (!SWIG_IsOK(ecode2)) {
28990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28991 }
28992 arg2 = static_cast< int >(val2);
28993 }
28994 {
28995 PyThreadState* __tstate = wxPyBeginAllowThreads();
28996 (arg1)->Exit(arg2);
28997 wxPyEndAllowThreads(__tstate);
28998 if (PyErr_Occurred()) SWIG_fail;
28999 }
29000 resultobj = SWIG_Py_Void();
29001 return resultobj;
29002 fail:
29003 return NULL;
29004 }
29005
29006
29007 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29008 PyObject *resultobj = 0;
29009 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29010 bool result;
29011 void *argp1 = 0 ;
29012 int res1 = 0 ;
29013 PyObject *swig_obj[1] ;
29014
29015 if (!args) SWIG_fail;
29016 swig_obj[0] = args;
29017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29018 if (!SWIG_IsOK(res1)) {
29019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29020 }
29021 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29022 {
29023 PyThreadState* __tstate = wxPyBeginAllowThreads();
29024 result = (bool)((wxEventLoop const *)arg1)->Pending();
29025 wxPyEndAllowThreads(__tstate);
29026 if (PyErr_Occurred()) SWIG_fail;
29027 }
29028 {
29029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29030 }
29031 return resultobj;
29032 fail:
29033 return NULL;
29034 }
29035
29036
29037 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29038 PyObject *resultobj = 0;
29039 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29040 bool result;
29041 void *argp1 = 0 ;
29042 int res1 = 0 ;
29043 PyObject *swig_obj[1] ;
29044
29045 if (!args) SWIG_fail;
29046 swig_obj[0] = args;
29047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29048 if (!SWIG_IsOK(res1)) {
29049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29050 }
29051 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29052 {
29053 PyThreadState* __tstate = wxPyBeginAllowThreads();
29054 result = (bool)(arg1)->Dispatch();
29055 wxPyEndAllowThreads(__tstate);
29056 if (PyErr_Occurred()) SWIG_fail;
29057 }
29058 {
29059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29060 }
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29068 PyObject *resultobj = 0;
29069 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29070 bool result;
29071 void *argp1 = 0 ;
29072 int res1 = 0 ;
29073 PyObject *swig_obj[1] ;
29074
29075 if (!args) SWIG_fail;
29076 swig_obj[0] = args;
29077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29078 if (!SWIG_IsOK(res1)) {
29079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29080 }
29081 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29082 {
29083 PyThreadState* __tstate = wxPyBeginAllowThreads();
29084 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29085 wxPyEndAllowThreads(__tstate);
29086 if (PyErr_Occurred()) SWIG_fail;
29087 }
29088 {
29089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29090 }
29091 return resultobj;
29092 fail:
29093 return NULL;
29094 }
29095
29096
29097 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29098 PyObject *resultobj = 0;
29099 wxEventLoop *result = 0 ;
29100
29101 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29102 {
29103 PyThreadState* __tstate = wxPyBeginAllowThreads();
29104 result = (wxEventLoop *)wxEventLoop::GetActive();
29105 wxPyEndAllowThreads(__tstate);
29106 if (PyErr_Occurred()) SWIG_fail;
29107 }
29108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29109 return resultobj;
29110 fail:
29111 return NULL;
29112 }
29113
29114
29115 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29116 PyObject *resultobj = 0;
29117 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29118 void *argp1 = 0 ;
29119 int res1 = 0 ;
29120 PyObject * obj0 = 0 ;
29121 char * kwnames[] = {
29122 (char *) "loop", NULL
29123 };
29124
29125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29127 if (!SWIG_IsOK(res1)) {
29128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29129 }
29130 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29131 {
29132 PyThreadState* __tstate = wxPyBeginAllowThreads();
29133 wxEventLoop::SetActive(arg1);
29134 wxPyEndAllowThreads(__tstate);
29135 if (PyErr_Occurred()) SWIG_fail;
29136 }
29137 resultobj = SWIG_Py_Void();
29138 return resultobj;
29139 fail:
29140 return NULL;
29141 }
29142
29143
29144 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29145 PyObject *obj;
29146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29147 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29148 return SWIG_Py_Void();
29149 }
29150
29151 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29152 return SWIG_Python_InitShadowInstance(args);
29153 }
29154
29155 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29156 PyObject *resultobj = 0;
29157 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29158 wxEventLoopActivator *result = 0 ;
29159 void *argp1 = 0 ;
29160 int res1 = 0 ;
29161 PyObject * obj0 = 0 ;
29162 char * kwnames[] = {
29163 (char *) "evtLoop", NULL
29164 };
29165
29166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29168 if (!SWIG_IsOK(res1)) {
29169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29170 }
29171 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29172 {
29173 PyThreadState* __tstate = wxPyBeginAllowThreads();
29174 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29175 wxPyEndAllowThreads(__tstate);
29176 if (PyErr_Occurred()) SWIG_fail;
29177 }
29178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29179 return resultobj;
29180 fail:
29181 return NULL;
29182 }
29183
29184
29185 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29186 PyObject *resultobj = 0;
29187 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29188 void *argp1 = 0 ;
29189 int res1 = 0 ;
29190 PyObject *swig_obj[1] ;
29191
29192 if (!args) SWIG_fail;
29193 swig_obj[0] = args;
29194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29195 if (!SWIG_IsOK(res1)) {
29196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29197 }
29198 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29199 {
29200 PyThreadState* __tstate = wxPyBeginAllowThreads();
29201 delete arg1;
29202
29203 wxPyEndAllowThreads(__tstate);
29204 if (PyErr_Occurred()) SWIG_fail;
29205 }
29206 resultobj = SWIG_Py_Void();
29207 return resultobj;
29208 fail:
29209 return NULL;
29210 }
29211
29212
29213 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29214 PyObject *obj;
29215 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29216 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29217 return SWIG_Py_Void();
29218 }
29219
29220 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29221 return SWIG_Python_InitShadowInstance(args);
29222 }
29223
29224 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29225 PyObject *resultobj = 0;
29226 int arg1 = (int) 0 ;
29227 int arg2 = (int) 0 ;
29228 int arg3 = (int) 0 ;
29229 wxAcceleratorEntry *result = 0 ;
29230 int val1 ;
29231 int ecode1 = 0 ;
29232 int val2 ;
29233 int ecode2 = 0 ;
29234 int val3 ;
29235 int ecode3 = 0 ;
29236 PyObject * obj0 = 0 ;
29237 PyObject * obj1 = 0 ;
29238 PyObject * obj2 = 0 ;
29239 char * kwnames[] = {
29240 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29241 };
29242
29243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29244 if (obj0) {
29245 ecode1 = SWIG_AsVal_int(obj0, &val1);
29246 if (!SWIG_IsOK(ecode1)) {
29247 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29248 }
29249 arg1 = static_cast< int >(val1);
29250 }
29251 if (obj1) {
29252 ecode2 = SWIG_AsVal_int(obj1, &val2);
29253 if (!SWIG_IsOK(ecode2)) {
29254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29255 }
29256 arg2 = static_cast< int >(val2);
29257 }
29258 if (obj2) {
29259 ecode3 = SWIG_AsVal_int(obj2, &val3);
29260 if (!SWIG_IsOK(ecode3)) {
29261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29262 }
29263 arg3 = static_cast< int >(val3);
29264 }
29265 {
29266 PyThreadState* __tstate = wxPyBeginAllowThreads();
29267 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29268 wxPyEndAllowThreads(__tstate);
29269 if (PyErr_Occurred()) SWIG_fail;
29270 }
29271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29272 return resultobj;
29273 fail:
29274 return NULL;
29275 }
29276
29277
29278 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29279 PyObject *resultobj = 0;
29280 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29281 void *argp1 = 0 ;
29282 int res1 = 0 ;
29283 PyObject *swig_obj[1] ;
29284
29285 if (!args) SWIG_fail;
29286 swig_obj[0] = args;
29287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29288 if (!SWIG_IsOK(res1)) {
29289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29290 }
29291 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29292 {
29293 PyThreadState* __tstate = wxPyBeginAllowThreads();
29294 delete arg1;
29295
29296 wxPyEndAllowThreads(__tstate);
29297 if (PyErr_Occurred()) SWIG_fail;
29298 }
29299 resultobj = SWIG_Py_Void();
29300 return resultobj;
29301 fail:
29302 return NULL;
29303 }
29304
29305
29306 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29307 PyObject *resultobj = 0;
29308 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29309 int arg2 ;
29310 int arg3 ;
29311 int arg4 ;
29312 void *argp1 = 0 ;
29313 int res1 = 0 ;
29314 int val2 ;
29315 int ecode2 = 0 ;
29316 int val3 ;
29317 int ecode3 = 0 ;
29318 int val4 ;
29319 int ecode4 = 0 ;
29320 PyObject * obj0 = 0 ;
29321 PyObject * obj1 = 0 ;
29322 PyObject * obj2 = 0 ;
29323 PyObject * obj3 = 0 ;
29324 char * kwnames[] = {
29325 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29326 };
29327
29328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29330 if (!SWIG_IsOK(res1)) {
29331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29332 }
29333 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29334 ecode2 = SWIG_AsVal_int(obj1, &val2);
29335 if (!SWIG_IsOK(ecode2)) {
29336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29337 }
29338 arg2 = static_cast< int >(val2);
29339 ecode3 = SWIG_AsVal_int(obj2, &val3);
29340 if (!SWIG_IsOK(ecode3)) {
29341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29342 }
29343 arg3 = static_cast< int >(val3);
29344 ecode4 = SWIG_AsVal_int(obj3, &val4);
29345 if (!SWIG_IsOK(ecode4)) {
29346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29347 }
29348 arg4 = static_cast< int >(val4);
29349 {
29350 PyThreadState* __tstate = wxPyBeginAllowThreads();
29351 (arg1)->Set(arg2,arg3,arg4);
29352 wxPyEndAllowThreads(__tstate);
29353 if (PyErr_Occurred()) SWIG_fail;
29354 }
29355 resultobj = SWIG_Py_Void();
29356 return resultobj;
29357 fail:
29358 return NULL;
29359 }
29360
29361
29362 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29363 PyObject *resultobj = 0;
29364 wxString *arg1 = 0 ;
29365 wxAcceleratorEntry *result = 0 ;
29366 bool temp1 = false ;
29367 PyObject * obj0 = 0 ;
29368 char * kwnames[] = {
29369 (char *) "str", NULL
29370 };
29371
29372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29373 {
29374 arg1 = wxString_in_helper(obj0);
29375 if (arg1 == NULL) SWIG_fail;
29376 temp1 = true;
29377 }
29378 {
29379 PyThreadState* __tstate = wxPyBeginAllowThreads();
29380 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29381 wxPyEndAllowThreads(__tstate);
29382 if (PyErr_Occurred()) SWIG_fail;
29383 }
29384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29385 {
29386 if (temp1)
29387 delete arg1;
29388 }
29389 return resultobj;
29390 fail:
29391 {
29392 if (temp1)
29393 delete arg1;
29394 }
29395 return NULL;
29396 }
29397
29398
29399 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29400 PyObject *resultobj = 0;
29401 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29402 int result;
29403 void *argp1 = 0 ;
29404 int res1 = 0 ;
29405 PyObject *swig_obj[1] ;
29406
29407 if (!args) SWIG_fail;
29408 swig_obj[0] = args;
29409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29410 if (!SWIG_IsOK(res1)) {
29411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29412 }
29413 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29414 {
29415 PyThreadState* __tstate = wxPyBeginAllowThreads();
29416 result = (int)(arg1)->GetFlags();
29417 wxPyEndAllowThreads(__tstate);
29418 if (PyErr_Occurred()) SWIG_fail;
29419 }
29420 resultobj = SWIG_From_int(static_cast< int >(result));
29421 return resultobj;
29422 fail:
29423 return NULL;
29424 }
29425
29426
29427 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29428 PyObject *resultobj = 0;
29429 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29430 int result;
29431 void *argp1 = 0 ;
29432 int res1 = 0 ;
29433 PyObject *swig_obj[1] ;
29434
29435 if (!args) SWIG_fail;
29436 swig_obj[0] = args;
29437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29438 if (!SWIG_IsOK(res1)) {
29439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29440 }
29441 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29442 {
29443 PyThreadState* __tstate = wxPyBeginAllowThreads();
29444 result = (int)(arg1)->GetKeyCode();
29445 wxPyEndAllowThreads(__tstate);
29446 if (PyErr_Occurred()) SWIG_fail;
29447 }
29448 resultobj = SWIG_From_int(static_cast< int >(result));
29449 return resultobj;
29450 fail:
29451 return NULL;
29452 }
29453
29454
29455 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29456 PyObject *resultobj = 0;
29457 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29458 int result;
29459 void *argp1 = 0 ;
29460 int res1 = 0 ;
29461 PyObject *swig_obj[1] ;
29462
29463 if (!args) SWIG_fail;
29464 swig_obj[0] = args;
29465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29466 if (!SWIG_IsOK(res1)) {
29467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29468 }
29469 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29470 {
29471 PyThreadState* __tstate = wxPyBeginAllowThreads();
29472 result = (int)(arg1)->GetCommand();
29473 wxPyEndAllowThreads(__tstate);
29474 if (PyErr_Occurred()) SWIG_fail;
29475 }
29476 resultobj = SWIG_From_int(static_cast< int >(result));
29477 return resultobj;
29478 fail:
29479 return NULL;
29480 }
29481
29482
29483 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29484 PyObject *resultobj = 0;
29485 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29486 bool result;
29487 void *argp1 = 0 ;
29488 int res1 = 0 ;
29489 PyObject *swig_obj[1] ;
29490
29491 if (!args) SWIG_fail;
29492 swig_obj[0] = args;
29493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29494 if (!SWIG_IsOK(res1)) {
29495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29496 }
29497 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29498 {
29499 PyThreadState* __tstate = wxPyBeginAllowThreads();
29500 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29501 wxPyEndAllowThreads(__tstate);
29502 if (PyErr_Occurred()) SWIG_fail;
29503 }
29504 {
29505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29506 }
29507 return resultobj;
29508 fail:
29509 return NULL;
29510 }
29511
29512
29513 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29514 PyObject *resultobj = 0;
29515 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29516 wxString result;
29517 void *argp1 = 0 ;
29518 int res1 = 0 ;
29519 PyObject *swig_obj[1] ;
29520
29521 if (!args) SWIG_fail;
29522 swig_obj[0] = args;
29523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29524 if (!SWIG_IsOK(res1)) {
29525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29526 }
29527 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29528 {
29529 PyThreadState* __tstate = wxPyBeginAllowThreads();
29530 result = ((wxAcceleratorEntry const *)arg1)->ToString();
29531 wxPyEndAllowThreads(__tstate);
29532 if (PyErr_Occurred()) SWIG_fail;
29533 }
29534 {
29535 #if wxUSE_UNICODE
29536 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29537 #else
29538 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29539 #endif
29540 }
29541 return resultobj;
29542 fail:
29543 return NULL;
29544 }
29545
29546
29547 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29548 PyObject *resultobj = 0;
29549 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29550 wxString *arg2 = 0 ;
29551 bool result;
29552 void *argp1 = 0 ;
29553 int res1 = 0 ;
29554 bool temp2 = false ;
29555 PyObject * obj0 = 0 ;
29556 PyObject * obj1 = 0 ;
29557 char * kwnames[] = {
29558 (char *) "self",(char *) "str", NULL
29559 };
29560
29561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
29562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29563 if (!SWIG_IsOK(res1)) {
29564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29565 }
29566 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29567 {
29568 arg2 = wxString_in_helper(obj1);
29569 if (arg2 == NULL) SWIG_fail;
29570 temp2 = true;
29571 }
29572 {
29573 PyThreadState* __tstate = wxPyBeginAllowThreads();
29574 result = (bool)(arg1)->FromString((wxString const &)*arg2);
29575 wxPyEndAllowThreads(__tstate);
29576 if (PyErr_Occurred()) SWIG_fail;
29577 }
29578 {
29579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29580 }
29581 {
29582 if (temp2)
29583 delete arg2;
29584 }
29585 return resultobj;
29586 fail:
29587 {
29588 if (temp2)
29589 delete arg2;
29590 }
29591 return NULL;
29592 }
29593
29594
29595 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29596 PyObject *obj;
29597 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29598 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29599 return SWIG_Py_Void();
29600 }
29601
29602 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29603 return SWIG_Python_InitShadowInstance(args);
29604 }
29605
29606 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29607 PyObject *resultobj = 0;
29608 int arg1 ;
29609 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29610 wxAcceleratorTable *result = 0 ;
29611 PyObject * obj0 = 0 ;
29612 char * kwnames[] = {
29613 (char *) "n", NULL
29614 };
29615
29616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29617 {
29618 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29619 if (arg2) arg1 = PyList_Size(obj0);
29620 else arg1 = 0;
29621 }
29622 {
29623 PyThreadState* __tstate = wxPyBeginAllowThreads();
29624 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29625 wxPyEndAllowThreads(__tstate);
29626 if (PyErr_Occurred()) SWIG_fail;
29627 }
29628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29629 return resultobj;
29630 fail:
29631 return NULL;
29632 }
29633
29634
29635 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29636 PyObject *resultobj = 0;
29637 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29638 void *argp1 = 0 ;
29639 int res1 = 0 ;
29640 PyObject *swig_obj[1] ;
29641
29642 if (!args) SWIG_fail;
29643 swig_obj[0] = args;
29644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29645 if (!SWIG_IsOK(res1)) {
29646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29647 }
29648 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29649 {
29650 PyThreadState* __tstate = wxPyBeginAllowThreads();
29651 delete arg1;
29652
29653 wxPyEndAllowThreads(__tstate);
29654 if (PyErr_Occurred()) SWIG_fail;
29655 }
29656 resultobj = SWIG_Py_Void();
29657 return resultobj;
29658 fail:
29659 return NULL;
29660 }
29661
29662
29663 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29664 PyObject *resultobj = 0;
29665 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29666 bool result;
29667 void *argp1 = 0 ;
29668 int res1 = 0 ;
29669 PyObject *swig_obj[1] ;
29670
29671 if (!args) SWIG_fail;
29672 swig_obj[0] = args;
29673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29674 if (!SWIG_IsOK(res1)) {
29675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29676 }
29677 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29678 {
29679 PyThreadState* __tstate = wxPyBeginAllowThreads();
29680 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29681 wxPyEndAllowThreads(__tstate);
29682 if (PyErr_Occurred()) SWIG_fail;
29683 }
29684 {
29685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29686 }
29687 return resultobj;
29688 fail:
29689 return NULL;
29690 }
29691
29692
29693 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29694 PyObject *obj;
29695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29696 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29697 return SWIG_Py_Void();
29698 }
29699
29700 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29701 return SWIG_Python_InitShadowInstance(args);
29702 }
29703
29704 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29705 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29706 return 1;
29707 }
29708
29709
29710 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29711 PyObject *pyobj = 0;
29712
29713 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29714 return pyobj;
29715 }
29716
29717
29718 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29719 PyObject *resultobj = 0;
29720 wxString *arg1 = 0 ;
29721 wxAcceleratorEntry *result = 0 ;
29722 bool temp1 = false ;
29723 PyObject * obj0 = 0 ;
29724 char * kwnames[] = {
29725 (char *) "label", NULL
29726 };
29727
29728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29729 {
29730 arg1 = wxString_in_helper(obj0);
29731 if (arg1 == NULL) SWIG_fail;
29732 temp1 = true;
29733 }
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29737 wxPyEndAllowThreads(__tstate);
29738 if (PyErr_Occurred()) SWIG_fail;
29739 }
29740 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29741 {
29742 if (temp1)
29743 delete arg1;
29744 }
29745 return resultobj;
29746 fail:
29747 {
29748 if (temp1)
29749 delete arg1;
29750 }
29751 return NULL;
29752 }
29753
29754
29755 SWIGINTERN int PanelNameStr_set(PyObject *) {
29756 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29757 return 1;
29758 }
29759
29760
29761 SWIGINTERN PyObject *PanelNameStr_get(void) {
29762 PyObject *pyobj = 0;
29763
29764 {
29765 #if wxUSE_UNICODE
29766 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29767 #else
29768 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29769 #endif
29770 }
29771 return pyobj;
29772 }
29773
29774
29775 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29776 PyObject *resultobj = 0;
29777 wxVisualAttributes *result = 0 ;
29778
29779 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29780 {
29781 PyThreadState* __tstate = wxPyBeginAllowThreads();
29782 result = (wxVisualAttributes *)new_wxVisualAttributes();
29783 wxPyEndAllowThreads(__tstate);
29784 if (PyErr_Occurred()) SWIG_fail;
29785 }
29786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29787 return resultobj;
29788 fail:
29789 return NULL;
29790 }
29791
29792
29793 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29794 PyObject *resultobj = 0;
29795 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29796 void *argp1 = 0 ;
29797 int res1 = 0 ;
29798 PyObject *swig_obj[1] ;
29799
29800 if (!args) SWIG_fail;
29801 swig_obj[0] = args;
29802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29803 if (!SWIG_IsOK(res1)) {
29804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29805 }
29806 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29807 {
29808 PyThreadState* __tstate = wxPyBeginAllowThreads();
29809 delete_wxVisualAttributes(arg1);
29810
29811 wxPyEndAllowThreads(__tstate);
29812 if (PyErr_Occurred()) SWIG_fail;
29813 }
29814 resultobj = SWIG_Py_Void();
29815 return resultobj;
29816 fail:
29817 return NULL;
29818 }
29819
29820
29821 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29822 PyObject *resultobj = 0;
29823 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29824 wxFont *arg2 = (wxFont *) 0 ;
29825 void *argp1 = 0 ;
29826 int res1 = 0 ;
29827 void *argp2 = 0 ;
29828 int res2 = 0 ;
29829 PyObject *swig_obj[2] ;
29830
29831 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29833 if (!SWIG_IsOK(res1)) {
29834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29835 }
29836 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29837 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29838 if (!SWIG_IsOK(res2)) {
29839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29840 }
29841 arg2 = reinterpret_cast< wxFont * >(argp2);
29842 if (arg1) (arg1)->font = *arg2;
29843
29844 resultobj = SWIG_Py_Void();
29845 return resultobj;
29846 fail:
29847 return NULL;
29848 }
29849
29850
29851 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29852 PyObject *resultobj = 0;
29853 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29854 wxFont *result = 0 ;
29855 void *argp1 = 0 ;
29856 int res1 = 0 ;
29857 PyObject *swig_obj[1] ;
29858
29859 if (!args) SWIG_fail;
29860 swig_obj[0] = args;
29861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29862 if (!SWIG_IsOK(res1)) {
29863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29864 }
29865 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29866 result = (wxFont *)& ((arg1)->font);
29867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29868 return resultobj;
29869 fail:
29870 return NULL;
29871 }
29872
29873
29874 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29875 PyObject *resultobj = 0;
29876 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29877 wxColour *arg2 = (wxColour *) 0 ;
29878 void *argp1 = 0 ;
29879 int res1 = 0 ;
29880 void *argp2 = 0 ;
29881 int res2 = 0 ;
29882 PyObject *swig_obj[2] ;
29883
29884 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29886 if (!SWIG_IsOK(res1)) {
29887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29888 }
29889 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29890 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29891 if (!SWIG_IsOK(res2)) {
29892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29893 }
29894 arg2 = reinterpret_cast< wxColour * >(argp2);
29895 if (arg1) (arg1)->colFg = *arg2;
29896
29897 resultobj = SWIG_Py_Void();
29898 return resultobj;
29899 fail:
29900 return NULL;
29901 }
29902
29903
29904 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29905 PyObject *resultobj = 0;
29906 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29907 wxColour *result = 0 ;
29908 void *argp1 = 0 ;
29909 int res1 = 0 ;
29910 PyObject *swig_obj[1] ;
29911
29912 if (!args) SWIG_fail;
29913 swig_obj[0] = args;
29914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29915 if (!SWIG_IsOK(res1)) {
29916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29917 }
29918 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29919 result = (wxColour *)& ((arg1)->colFg);
29920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29921 return resultobj;
29922 fail:
29923 return NULL;
29924 }
29925
29926
29927 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29928 PyObject *resultobj = 0;
29929 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29930 wxColour *arg2 = (wxColour *) 0 ;
29931 void *argp1 = 0 ;
29932 int res1 = 0 ;
29933 void *argp2 = 0 ;
29934 int res2 = 0 ;
29935 PyObject *swig_obj[2] ;
29936
29937 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29939 if (!SWIG_IsOK(res1)) {
29940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29941 }
29942 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29943 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29944 if (!SWIG_IsOK(res2)) {
29945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29946 }
29947 arg2 = reinterpret_cast< wxColour * >(argp2);
29948 if (arg1) (arg1)->colBg = *arg2;
29949
29950 resultobj = SWIG_Py_Void();
29951 return resultobj;
29952 fail:
29953 return NULL;
29954 }
29955
29956
29957 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29958 PyObject *resultobj = 0;
29959 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29960 wxColour *result = 0 ;
29961 void *argp1 = 0 ;
29962 int res1 = 0 ;
29963 PyObject *swig_obj[1] ;
29964
29965 if (!args) SWIG_fail;
29966 swig_obj[0] = args;
29967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29968 if (!SWIG_IsOK(res1)) {
29969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29970 }
29971 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29972 result = (wxColour *)& ((arg1)->colBg);
29973 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29974 return resultobj;
29975 fail:
29976 return NULL;
29977 }
29978
29979
29980 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29981 PyObject *obj;
29982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29983 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29984 return SWIG_Py_Void();
29985 }
29986
29987 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29988 return SWIG_Python_InitShadowInstance(args);
29989 }
29990
29991 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29992 PyObject *resultobj = 0;
29993 wxWindow *arg1 = (wxWindow *) 0 ;
29994 int arg2 = (int) (int)-1 ;
29995 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29996 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29997 wxSize const &arg4_defvalue = wxDefaultSize ;
29998 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29999 long arg5 = (long) 0 ;
30000 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30001 wxString *arg6 = (wxString *) &arg6_defvalue ;
30002 wxWindow *result = 0 ;
30003 void *argp1 = 0 ;
30004 int res1 = 0 ;
30005 int val2 ;
30006 int ecode2 = 0 ;
30007 wxPoint temp3 ;
30008 wxSize temp4 ;
30009 long val5 ;
30010 int ecode5 = 0 ;
30011 bool temp6 = false ;
30012 PyObject * obj0 = 0 ;
30013 PyObject * obj1 = 0 ;
30014 PyObject * obj2 = 0 ;
30015 PyObject * obj3 = 0 ;
30016 PyObject * obj4 = 0 ;
30017 PyObject * obj5 = 0 ;
30018 char * kwnames[] = {
30019 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30020 };
30021
30022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30024 if (!SWIG_IsOK(res1)) {
30025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30026 }
30027 arg1 = reinterpret_cast< wxWindow * >(argp1);
30028 if (obj1) {
30029 ecode2 = SWIG_AsVal_int(obj1, &val2);
30030 if (!SWIG_IsOK(ecode2)) {
30031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30032 }
30033 arg2 = static_cast< int >(val2);
30034 }
30035 if (obj2) {
30036 {
30037 arg3 = &temp3;
30038 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30039 }
30040 }
30041 if (obj3) {
30042 {
30043 arg4 = &temp4;
30044 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30045 }
30046 }
30047 if (obj4) {
30048 ecode5 = SWIG_AsVal_long(obj4, &val5);
30049 if (!SWIG_IsOK(ecode5)) {
30050 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30051 }
30052 arg5 = static_cast< long >(val5);
30053 }
30054 if (obj5) {
30055 {
30056 arg6 = wxString_in_helper(obj5);
30057 if (arg6 == NULL) SWIG_fail;
30058 temp6 = true;
30059 }
30060 }
30061 {
30062 if (!wxPyCheckForApp()) SWIG_fail;
30063 PyThreadState* __tstate = wxPyBeginAllowThreads();
30064 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30065 wxPyEndAllowThreads(__tstate);
30066 if (PyErr_Occurred()) SWIG_fail;
30067 }
30068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30069 {
30070 if (temp6)
30071 delete arg6;
30072 }
30073 return resultobj;
30074 fail:
30075 {
30076 if (temp6)
30077 delete arg6;
30078 }
30079 return NULL;
30080 }
30081
30082
30083 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30084 PyObject *resultobj = 0;
30085 wxWindow *result = 0 ;
30086
30087 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30088 {
30089 if (!wxPyCheckForApp()) SWIG_fail;
30090 PyThreadState* __tstate = wxPyBeginAllowThreads();
30091 result = (wxWindow *)new wxWindow();
30092 wxPyEndAllowThreads(__tstate);
30093 if (PyErr_Occurred()) SWIG_fail;
30094 }
30095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30096 return resultobj;
30097 fail:
30098 return NULL;
30099 }
30100
30101
30102 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30103 PyObject *resultobj = 0;
30104 wxWindow *arg1 = (wxWindow *) 0 ;
30105 wxWindow *arg2 = (wxWindow *) 0 ;
30106 int arg3 = (int) (int)-1 ;
30107 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30108 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30109 wxSize const &arg5_defvalue = wxDefaultSize ;
30110 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30111 long arg6 = (long) 0 ;
30112 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30113 wxString *arg7 = (wxString *) &arg7_defvalue ;
30114 bool result;
30115 void *argp1 = 0 ;
30116 int res1 = 0 ;
30117 void *argp2 = 0 ;
30118 int res2 = 0 ;
30119 int val3 ;
30120 int ecode3 = 0 ;
30121 wxPoint temp4 ;
30122 wxSize temp5 ;
30123 long val6 ;
30124 int ecode6 = 0 ;
30125 bool temp7 = false ;
30126 PyObject * obj0 = 0 ;
30127 PyObject * obj1 = 0 ;
30128 PyObject * obj2 = 0 ;
30129 PyObject * obj3 = 0 ;
30130 PyObject * obj4 = 0 ;
30131 PyObject * obj5 = 0 ;
30132 PyObject * obj6 = 0 ;
30133 char * kwnames[] = {
30134 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30135 };
30136
30137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30139 if (!SWIG_IsOK(res1)) {
30140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30141 }
30142 arg1 = reinterpret_cast< wxWindow * >(argp1);
30143 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30144 if (!SWIG_IsOK(res2)) {
30145 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30146 }
30147 arg2 = reinterpret_cast< wxWindow * >(argp2);
30148 if (obj2) {
30149 ecode3 = SWIG_AsVal_int(obj2, &val3);
30150 if (!SWIG_IsOK(ecode3)) {
30151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30152 }
30153 arg3 = static_cast< int >(val3);
30154 }
30155 if (obj3) {
30156 {
30157 arg4 = &temp4;
30158 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30159 }
30160 }
30161 if (obj4) {
30162 {
30163 arg5 = &temp5;
30164 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30165 }
30166 }
30167 if (obj5) {
30168 ecode6 = SWIG_AsVal_long(obj5, &val6);
30169 if (!SWIG_IsOK(ecode6)) {
30170 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30171 }
30172 arg6 = static_cast< long >(val6);
30173 }
30174 if (obj6) {
30175 {
30176 arg7 = wxString_in_helper(obj6);
30177 if (arg7 == NULL) SWIG_fail;
30178 temp7 = true;
30179 }
30180 }
30181 {
30182 PyThreadState* __tstate = wxPyBeginAllowThreads();
30183 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30184 wxPyEndAllowThreads(__tstate);
30185 if (PyErr_Occurred()) SWIG_fail;
30186 }
30187 {
30188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30189 }
30190 {
30191 if (temp7)
30192 delete arg7;
30193 }
30194 return resultobj;
30195 fail:
30196 {
30197 if (temp7)
30198 delete arg7;
30199 }
30200 return NULL;
30201 }
30202
30203
30204 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30205 PyObject *resultobj = 0;
30206 wxWindow *arg1 = (wxWindow *) 0 ;
30207 bool arg2 = (bool) false ;
30208 bool result;
30209 void *argp1 = 0 ;
30210 int res1 = 0 ;
30211 bool val2 ;
30212 int ecode2 = 0 ;
30213 PyObject * obj0 = 0 ;
30214 PyObject * obj1 = 0 ;
30215 char * kwnames[] = {
30216 (char *) "self",(char *) "force", NULL
30217 };
30218
30219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) 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_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30223 }
30224 arg1 = reinterpret_cast< wxWindow * >(argp1);
30225 if (obj1) {
30226 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30227 if (!SWIG_IsOK(ecode2)) {
30228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30229 }
30230 arg2 = static_cast< bool >(val2);
30231 }
30232 {
30233 PyThreadState* __tstate = wxPyBeginAllowThreads();
30234 result = (bool)(arg1)->Close(arg2);
30235 wxPyEndAllowThreads(__tstate);
30236 if (PyErr_Occurred()) SWIG_fail;
30237 }
30238 {
30239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30240 }
30241 return resultobj;
30242 fail:
30243 return NULL;
30244 }
30245
30246
30247 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30248 PyObject *resultobj = 0;
30249 wxWindow *arg1 = (wxWindow *) 0 ;
30250 bool result;
30251 void *argp1 = 0 ;
30252 int res1 = 0 ;
30253 PyObject *swig_obj[1] ;
30254
30255 if (!args) SWIG_fail;
30256 swig_obj[0] = args;
30257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30258 if (!SWIG_IsOK(res1)) {
30259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30260 }
30261 arg1 = reinterpret_cast< wxWindow * >(argp1);
30262 {
30263 PyThreadState* __tstate = wxPyBeginAllowThreads();
30264 result = (bool)(arg1)->Destroy();
30265 wxPyEndAllowThreads(__tstate);
30266 if (PyErr_Occurred()) SWIG_fail;
30267 }
30268 {
30269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30270 }
30271 return resultobj;
30272 fail:
30273 return NULL;
30274 }
30275
30276
30277 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30278 PyObject *resultobj = 0;
30279 wxWindow *arg1 = (wxWindow *) 0 ;
30280 bool result;
30281 void *argp1 = 0 ;
30282 int res1 = 0 ;
30283 PyObject *swig_obj[1] ;
30284
30285 if (!args) SWIG_fail;
30286 swig_obj[0] = args;
30287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30288 if (!SWIG_IsOK(res1)) {
30289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30290 }
30291 arg1 = reinterpret_cast< wxWindow * >(argp1);
30292 {
30293 PyThreadState* __tstate = wxPyBeginAllowThreads();
30294 result = (bool)(arg1)->DestroyChildren();
30295 wxPyEndAllowThreads(__tstate);
30296 if (PyErr_Occurred()) SWIG_fail;
30297 }
30298 {
30299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30300 }
30301 return resultobj;
30302 fail:
30303 return NULL;
30304 }
30305
30306
30307 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30308 PyObject *resultobj = 0;
30309 wxWindow *arg1 = (wxWindow *) 0 ;
30310 bool result;
30311 void *argp1 = 0 ;
30312 int res1 = 0 ;
30313 PyObject *swig_obj[1] ;
30314
30315 if (!args) SWIG_fail;
30316 swig_obj[0] = args;
30317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30318 if (!SWIG_IsOK(res1)) {
30319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30320 }
30321 arg1 = reinterpret_cast< wxWindow * >(argp1);
30322 {
30323 PyThreadState* __tstate = wxPyBeginAllowThreads();
30324 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30325 wxPyEndAllowThreads(__tstate);
30326 if (PyErr_Occurred()) SWIG_fail;
30327 }
30328 {
30329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30330 }
30331 return resultobj;
30332 fail:
30333 return NULL;
30334 }
30335
30336
30337 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30338 PyObject *resultobj = 0;
30339 wxWindow *arg1 = (wxWindow *) 0 ;
30340 wxString *arg2 = 0 ;
30341 void *argp1 = 0 ;
30342 int res1 = 0 ;
30343 bool temp2 = false ;
30344 PyObject * obj0 = 0 ;
30345 PyObject * obj1 = 0 ;
30346 char * kwnames[] = {
30347 (char *) "self",(char *) "label", NULL
30348 };
30349
30350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30352 if (!SWIG_IsOK(res1)) {
30353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30354 }
30355 arg1 = reinterpret_cast< wxWindow * >(argp1);
30356 {
30357 arg2 = wxString_in_helper(obj1);
30358 if (arg2 == NULL) SWIG_fail;
30359 temp2 = true;
30360 }
30361 {
30362 PyThreadState* __tstate = wxPyBeginAllowThreads();
30363 (arg1)->SetLabel((wxString const &)*arg2);
30364 wxPyEndAllowThreads(__tstate);
30365 if (PyErr_Occurred()) SWIG_fail;
30366 }
30367 resultobj = SWIG_Py_Void();
30368 {
30369 if (temp2)
30370 delete arg2;
30371 }
30372 return resultobj;
30373 fail:
30374 {
30375 if (temp2)
30376 delete arg2;
30377 }
30378 return NULL;
30379 }
30380
30381
30382 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30383 PyObject *resultobj = 0;
30384 wxWindow *arg1 = (wxWindow *) 0 ;
30385 wxString result;
30386 void *argp1 = 0 ;
30387 int res1 = 0 ;
30388 PyObject *swig_obj[1] ;
30389
30390 if (!args) SWIG_fail;
30391 swig_obj[0] = args;
30392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30393 if (!SWIG_IsOK(res1)) {
30394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30395 }
30396 arg1 = reinterpret_cast< wxWindow * >(argp1);
30397 {
30398 PyThreadState* __tstate = wxPyBeginAllowThreads();
30399 result = ((wxWindow const *)arg1)->GetLabel();
30400 wxPyEndAllowThreads(__tstate);
30401 if (PyErr_Occurred()) SWIG_fail;
30402 }
30403 {
30404 #if wxUSE_UNICODE
30405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30406 #else
30407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30408 #endif
30409 }
30410 return resultobj;
30411 fail:
30412 return NULL;
30413 }
30414
30415
30416 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30417 PyObject *resultobj = 0;
30418 wxWindow *arg1 = (wxWindow *) 0 ;
30419 wxString *arg2 = 0 ;
30420 void *argp1 = 0 ;
30421 int res1 = 0 ;
30422 bool temp2 = false ;
30423 PyObject * obj0 = 0 ;
30424 PyObject * obj1 = 0 ;
30425 char * kwnames[] = {
30426 (char *) "self",(char *) "name", NULL
30427 };
30428
30429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30431 if (!SWIG_IsOK(res1)) {
30432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30433 }
30434 arg1 = reinterpret_cast< wxWindow * >(argp1);
30435 {
30436 arg2 = wxString_in_helper(obj1);
30437 if (arg2 == NULL) SWIG_fail;
30438 temp2 = true;
30439 }
30440 {
30441 PyThreadState* __tstate = wxPyBeginAllowThreads();
30442 (arg1)->SetName((wxString const &)*arg2);
30443 wxPyEndAllowThreads(__tstate);
30444 if (PyErr_Occurred()) SWIG_fail;
30445 }
30446 resultobj = SWIG_Py_Void();
30447 {
30448 if (temp2)
30449 delete arg2;
30450 }
30451 return resultobj;
30452 fail:
30453 {
30454 if (temp2)
30455 delete arg2;
30456 }
30457 return NULL;
30458 }
30459
30460
30461 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30462 PyObject *resultobj = 0;
30463 wxWindow *arg1 = (wxWindow *) 0 ;
30464 wxString result;
30465 void *argp1 = 0 ;
30466 int res1 = 0 ;
30467 PyObject *swig_obj[1] ;
30468
30469 if (!args) SWIG_fail;
30470 swig_obj[0] = args;
30471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30472 if (!SWIG_IsOK(res1)) {
30473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30474 }
30475 arg1 = reinterpret_cast< wxWindow * >(argp1);
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 result = ((wxWindow const *)arg1)->GetName();
30479 wxPyEndAllowThreads(__tstate);
30480 if (PyErr_Occurred()) SWIG_fail;
30481 }
30482 {
30483 #if wxUSE_UNICODE
30484 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30485 #else
30486 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30487 #endif
30488 }
30489 return resultobj;
30490 fail:
30491 return NULL;
30492 }
30493
30494
30495 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30496 PyObject *resultobj = 0;
30497 wxWindow *arg1 = (wxWindow *) 0 ;
30498 wxWindowVariant arg2 ;
30499 void *argp1 = 0 ;
30500 int res1 = 0 ;
30501 int val2 ;
30502 int ecode2 = 0 ;
30503 PyObject * obj0 = 0 ;
30504 PyObject * obj1 = 0 ;
30505 char * kwnames[] = {
30506 (char *) "self",(char *) "variant", NULL
30507 };
30508
30509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30511 if (!SWIG_IsOK(res1)) {
30512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30513 }
30514 arg1 = reinterpret_cast< wxWindow * >(argp1);
30515 ecode2 = SWIG_AsVal_int(obj1, &val2);
30516 if (!SWIG_IsOK(ecode2)) {
30517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30518 }
30519 arg2 = static_cast< wxWindowVariant >(val2);
30520 {
30521 PyThreadState* __tstate = wxPyBeginAllowThreads();
30522 (arg1)->SetWindowVariant(arg2);
30523 wxPyEndAllowThreads(__tstate);
30524 if (PyErr_Occurred()) SWIG_fail;
30525 }
30526 resultobj = SWIG_Py_Void();
30527 return resultobj;
30528 fail:
30529 return NULL;
30530 }
30531
30532
30533 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30534 PyObject *resultobj = 0;
30535 wxWindow *arg1 = (wxWindow *) 0 ;
30536 wxWindowVariant result;
30537 void *argp1 = 0 ;
30538 int res1 = 0 ;
30539 PyObject *swig_obj[1] ;
30540
30541 if (!args) SWIG_fail;
30542 swig_obj[0] = args;
30543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30544 if (!SWIG_IsOK(res1)) {
30545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30546 }
30547 arg1 = reinterpret_cast< wxWindow * >(argp1);
30548 {
30549 PyThreadState* __tstate = wxPyBeginAllowThreads();
30550 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30551 wxPyEndAllowThreads(__tstate);
30552 if (PyErr_Occurred()) SWIG_fail;
30553 }
30554 resultobj = SWIG_From_int(static_cast< int >(result));
30555 return resultobj;
30556 fail:
30557 return NULL;
30558 }
30559
30560
30561 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30562 PyObject *resultobj = 0;
30563 wxWindow *arg1 = (wxWindow *) 0 ;
30564 int arg2 ;
30565 void *argp1 = 0 ;
30566 int res1 = 0 ;
30567 int val2 ;
30568 int ecode2 = 0 ;
30569 PyObject * obj0 = 0 ;
30570 PyObject * obj1 = 0 ;
30571 char * kwnames[] = {
30572 (char *) "self",(char *) "winid", NULL
30573 };
30574
30575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30577 if (!SWIG_IsOK(res1)) {
30578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30579 }
30580 arg1 = reinterpret_cast< wxWindow * >(argp1);
30581 ecode2 = SWIG_AsVal_int(obj1, &val2);
30582 if (!SWIG_IsOK(ecode2)) {
30583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30584 }
30585 arg2 = static_cast< int >(val2);
30586 {
30587 PyThreadState* __tstate = wxPyBeginAllowThreads();
30588 (arg1)->SetId(arg2);
30589 wxPyEndAllowThreads(__tstate);
30590 if (PyErr_Occurred()) SWIG_fail;
30591 }
30592 resultobj = SWIG_Py_Void();
30593 return resultobj;
30594 fail:
30595 return NULL;
30596 }
30597
30598
30599 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30600 PyObject *resultobj = 0;
30601 wxWindow *arg1 = (wxWindow *) 0 ;
30602 int result;
30603 void *argp1 = 0 ;
30604 int res1 = 0 ;
30605 PyObject *swig_obj[1] ;
30606
30607 if (!args) SWIG_fail;
30608 swig_obj[0] = args;
30609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30610 if (!SWIG_IsOK(res1)) {
30611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30612 }
30613 arg1 = reinterpret_cast< wxWindow * >(argp1);
30614 {
30615 PyThreadState* __tstate = wxPyBeginAllowThreads();
30616 result = (int)((wxWindow const *)arg1)->GetId();
30617 wxPyEndAllowThreads(__tstate);
30618 if (PyErr_Occurred()) SWIG_fail;
30619 }
30620 resultobj = SWIG_From_int(static_cast< int >(result));
30621 return resultobj;
30622 fail:
30623 return NULL;
30624 }
30625
30626
30627 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30628 PyObject *resultobj = 0;
30629 int result;
30630
30631 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30632 {
30633 PyThreadState* __tstate = wxPyBeginAllowThreads();
30634 result = (int)wxWindow::NewControlId();
30635 wxPyEndAllowThreads(__tstate);
30636 if (PyErr_Occurred()) SWIG_fail;
30637 }
30638 resultobj = SWIG_From_int(static_cast< int >(result));
30639 return resultobj;
30640 fail:
30641 return NULL;
30642 }
30643
30644
30645 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30646 PyObject *resultobj = 0;
30647 int arg1 ;
30648 int result;
30649 int val1 ;
30650 int ecode1 = 0 ;
30651 PyObject * obj0 = 0 ;
30652 char * kwnames[] = {
30653 (char *) "winid", NULL
30654 };
30655
30656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30657 ecode1 = SWIG_AsVal_int(obj0, &val1);
30658 if (!SWIG_IsOK(ecode1)) {
30659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30660 }
30661 arg1 = static_cast< int >(val1);
30662 {
30663 PyThreadState* __tstate = wxPyBeginAllowThreads();
30664 result = (int)wxWindow::NextControlId(arg1);
30665 wxPyEndAllowThreads(__tstate);
30666 if (PyErr_Occurred()) SWIG_fail;
30667 }
30668 resultobj = SWIG_From_int(static_cast< int >(result));
30669 return resultobj;
30670 fail:
30671 return NULL;
30672 }
30673
30674
30675 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30676 PyObject *resultobj = 0;
30677 int arg1 ;
30678 int result;
30679 int val1 ;
30680 int ecode1 = 0 ;
30681 PyObject * obj0 = 0 ;
30682 char * kwnames[] = {
30683 (char *) "winid", NULL
30684 };
30685
30686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30687 ecode1 = SWIG_AsVal_int(obj0, &val1);
30688 if (!SWIG_IsOK(ecode1)) {
30689 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30690 }
30691 arg1 = static_cast< int >(val1);
30692 {
30693 PyThreadState* __tstate = wxPyBeginAllowThreads();
30694 result = (int)wxWindow::PrevControlId(arg1);
30695 wxPyEndAllowThreads(__tstate);
30696 if (PyErr_Occurred()) SWIG_fail;
30697 }
30698 resultobj = SWIG_From_int(static_cast< int >(result));
30699 return resultobj;
30700 fail:
30701 return NULL;
30702 }
30703
30704
30705 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30706 PyObject *resultobj = 0;
30707 wxWindow *arg1 = (wxWindow *) 0 ;
30708 wxLayoutDirection result;
30709 void *argp1 = 0 ;
30710 int res1 = 0 ;
30711 PyObject *swig_obj[1] ;
30712
30713 if (!args) SWIG_fail;
30714 swig_obj[0] = args;
30715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30716 if (!SWIG_IsOK(res1)) {
30717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30718 }
30719 arg1 = reinterpret_cast< wxWindow * >(argp1);
30720 {
30721 PyThreadState* __tstate = wxPyBeginAllowThreads();
30722 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
30723 wxPyEndAllowThreads(__tstate);
30724 if (PyErr_Occurred()) SWIG_fail;
30725 }
30726 resultobj = SWIG_From_int(static_cast< int >(result));
30727 return resultobj;
30728 fail:
30729 return NULL;
30730 }
30731
30732
30733 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30734 PyObject *resultobj = 0;
30735 wxWindow *arg1 = (wxWindow *) 0 ;
30736 wxLayoutDirection arg2 ;
30737 void *argp1 = 0 ;
30738 int res1 = 0 ;
30739 int val2 ;
30740 int ecode2 = 0 ;
30741 PyObject * obj0 = 0 ;
30742 PyObject * obj1 = 0 ;
30743 char * kwnames[] = {
30744 (char *) "self",(char *) "dir", NULL
30745 };
30746
30747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
30748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30749 if (!SWIG_IsOK(res1)) {
30750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
30751 }
30752 arg1 = reinterpret_cast< wxWindow * >(argp1);
30753 ecode2 = SWIG_AsVal_int(obj1, &val2);
30754 if (!SWIG_IsOK(ecode2)) {
30755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30756 }
30757 arg2 = static_cast< wxLayoutDirection >(val2);
30758 {
30759 PyThreadState* __tstate = wxPyBeginAllowThreads();
30760 (arg1)->SetLayoutDirection(arg2);
30761 wxPyEndAllowThreads(__tstate);
30762 if (PyErr_Occurred()) SWIG_fail;
30763 }
30764 resultobj = SWIG_Py_Void();
30765 return resultobj;
30766 fail:
30767 return NULL;
30768 }
30769
30770
30771 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30772 PyObject *resultobj = 0;
30773 wxWindow *arg1 = (wxWindow *) 0 ;
30774 int arg2 ;
30775 int arg3 ;
30776 int arg4 ;
30777 int result;
30778 void *argp1 = 0 ;
30779 int res1 = 0 ;
30780 int val2 ;
30781 int ecode2 = 0 ;
30782 int val3 ;
30783 int ecode3 = 0 ;
30784 int val4 ;
30785 int ecode4 = 0 ;
30786 PyObject * obj0 = 0 ;
30787 PyObject * obj1 = 0 ;
30788 PyObject * obj2 = 0 ;
30789 PyObject * obj3 = 0 ;
30790 char * kwnames[] = {
30791 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
30792 };
30793
30794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30796 if (!SWIG_IsOK(res1)) {
30797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30798 }
30799 arg1 = reinterpret_cast< wxWindow * >(argp1);
30800 ecode2 = SWIG_AsVal_int(obj1, &val2);
30801 if (!SWIG_IsOK(ecode2)) {
30802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
30803 }
30804 arg2 = static_cast< int >(val2);
30805 ecode3 = SWIG_AsVal_int(obj2, &val3);
30806 if (!SWIG_IsOK(ecode3)) {
30807 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
30808 }
30809 arg3 = static_cast< int >(val3);
30810 ecode4 = SWIG_AsVal_int(obj3, &val4);
30811 if (!SWIG_IsOK(ecode4)) {
30812 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
30813 }
30814 arg4 = static_cast< int >(val4);
30815 {
30816 PyThreadState* __tstate = wxPyBeginAllowThreads();
30817 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
30818 wxPyEndAllowThreads(__tstate);
30819 if (PyErr_Occurred()) SWIG_fail;
30820 }
30821 resultobj = SWIG_From_int(static_cast< int >(result));
30822 return resultobj;
30823 fail:
30824 return NULL;
30825 }
30826
30827
30828 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30829 PyObject *resultobj = 0;
30830 wxWindow *arg1 = (wxWindow *) 0 ;
30831 wxSize *arg2 = 0 ;
30832 void *argp1 = 0 ;
30833 int res1 = 0 ;
30834 wxSize temp2 ;
30835 PyObject * obj0 = 0 ;
30836 PyObject * obj1 = 0 ;
30837 char * kwnames[] = {
30838 (char *) "self",(char *) "size", NULL
30839 };
30840
30841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30843 if (!SWIG_IsOK(res1)) {
30844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30845 }
30846 arg1 = reinterpret_cast< wxWindow * >(argp1);
30847 {
30848 arg2 = &temp2;
30849 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30850 }
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 (arg1)->SetSize((wxSize const &)*arg2);
30854 wxPyEndAllowThreads(__tstate);
30855 if (PyErr_Occurred()) SWIG_fail;
30856 }
30857 resultobj = SWIG_Py_Void();
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30865 PyObject *resultobj = 0;
30866 wxWindow *arg1 = (wxWindow *) 0 ;
30867 int arg2 ;
30868 int arg3 ;
30869 int arg4 ;
30870 int arg5 ;
30871 int arg6 = (int) wxSIZE_AUTO ;
30872 void *argp1 = 0 ;
30873 int res1 = 0 ;
30874 int val2 ;
30875 int ecode2 = 0 ;
30876 int val3 ;
30877 int ecode3 = 0 ;
30878 int val4 ;
30879 int ecode4 = 0 ;
30880 int val5 ;
30881 int ecode5 = 0 ;
30882 int val6 ;
30883 int ecode6 = 0 ;
30884 PyObject * obj0 = 0 ;
30885 PyObject * obj1 = 0 ;
30886 PyObject * obj2 = 0 ;
30887 PyObject * obj3 = 0 ;
30888 PyObject * obj4 = 0 ;
30889 PyObject * obj5 = 0 ;
30890 char * kwnames[] = {
30891 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30892 };
30893
30894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30896 if (!SWIG_IsOK(res1)) {
30897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30898 }
30899 arg1 = reinterpret_cast< wxWindow * >(argp1);
30900 ecode2 = SWIG_AsVal_int(obj1, &val2);
30901 if (!SWIG_IsOK(ecode2)) {
30902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30903 }
30904 arg2 = static_cast< int >(val2);
30905 ecode3 = SWIG_AsVal_int(obj2, &val3);
30906 if (!SWIG_IsOK(ecode3)) {
30907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30908 }
30909 arg3 = static_cast< int >(val3);
30910 ecode4 = SWIG_AsVal_int(obj3, &val4);
30911 if (!SWIG_IsOK(ecode4)) {
30912 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30913 }
30914 arg4 = static_cast< int >(val4);
30915 ecode5 = SWIG_AsVal_int(obj4, &val5);
30916 if (!SWIG_IsOK(ecode5)) {
30917 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30918 }
30919 arg5 = static_cast< int >(val5);
30920 if (obj5) {
30921 ecode6 = SWIG_AsVal_int(obj5, &val6);
30922 if (!SWIG_IsOK(ecode6)) {
30923 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30924 }
30925 arg6 = static_cast< int >(val6);
30926 }
30927 {
30928 PyThreadState* __tstate = wxPyBeginAllowThreads();
30929 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30930 wxPyEndAllowThreads(__tstate);
30931 if (PyErr_Occurred()) SWIG_fail;
30932 }
30933 resultobj = SWIG_Py_Void();
30934 return resultobj;
30935 fail:
30936 return NULL;
30937 }
30938
30939
30940 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30941 PyObject *resultobj = 0;
30942 wxWindow *arg1 = (wxWindow *) 0 ;
30943 wxRect *arg2 = 0 ;
30944 int arg3 = (int) wxSIZE_AUTO ;
30945 void *argp1 = 0 ;
30946 int res1 = 0 ;
30947 wxRect temp2 ;
30948 int val3 ;
30949 int ecode3 = 0 ;
30950 PyObject * obj0 = 0 ;
30951 PyObject * obj1 = 0 ;
30952 PyObject * obj2 = 0 ;
30953 char * kwnames[] = {
30954 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30955 };
30956
30957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30959 if (!SWIG_IsOK(res1)) {
30960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30961 }
30962 arg1 = reinterpret_cast< wxWindow * >(argp1);
30963 {
30964 arg2 = &temp2;
30965 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30966 }
30967 if (obj2) {
30968 ecode3 = SWIG_AsVal_int(obj2, &val3);
30969 if (!SWIG_IsOK(ecode3)) {
30970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30971 }
30972 arg3 = static_cast< int >(val3);
30973 }
30974 {
30975 PyThreadState* __tstate = wxPyBeginAllowThreads();
30976 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30977 wxPyEndAllowThreads(__tstate);
30978 if (PyErr_Occurred()) SWIG_fail;
30979 }
30980 resultobj = SWIG_Py_Void();
30981 return resultobj;
30982 fail:
30983 return NULL;
30984 }
30985
30986
30987 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30988 PyObject *resultobj = 0;
30989 wxWindow *arg1 = (wxWindow *) 0 ;
30990 int arg2 ;
30991 int arg3 ;
30992 void *argp1 = 0 ;
30993 int res1 = 0 ;
30994 int val2 ;
30995 int ecode2 = 0 ;
30996 int val3 ;
30997 int ecode3 = 0 ;
30998 PyObject * obj0 = 0 ;
30999 PyObject * obj1 = 0 ;
31000 PyObject * obj2 = 0 ;
31001 char * kwnames[] = {
31002 (char *) "self",(char *) "width",(char *) "height", NULL
31003 };
31004
31005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31007 if (!SWIG_IsOK(res1)) {
31008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31009 }
31010 arg1 = reinterpret_cast< wxWindow * >(argp1);
31011 ecode2 = SWIG_AsVal_int(obj1, &val2);
31012 if (!SWIG_IsOK(ecode2)) {
31013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31014 }
31015 arg2 = static_cast< int >(val2);
31016 ecode3 = SWIG_AsVal_int(obj2, &val3);
31017 if (!SWIG_IsOK(ecode3)) {
31018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31019 }
31020 arg3 = static_cast< int >(val3);
31021 {
31022 PyThreadState* __tstate = wxPyBeginAllowThreads();
31023 (arg1)->SetSize(arg2,arg3);
31024 wxPyEndAllowThreads(__tstate);
31025 if (PyErr_Occurred()) SWIG_fail;
31026 }
31027 resultobj = SWIG_Py_Void();
31028 return resultobj;
31029 fail:
31030 return NULL;
31031 }
31032
31033
31034 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31035 PyObject *resultobj = 0;
31036 wxWindow *arg1 = (wxWindow *) 0 ;
31037 wxPoint *arg2 = 0 ;
31038 int arg3 = (int) wxSIZE_USE_EXISTING ;
31039 void *argp1 = 0 ;
31040 int res1 = 0 ;
31041 wxPoint temp2 ;
31042 int val3 ;
31043 int ecode3 = 0 ;
31044 PyObject * obj0 = 0 ;
31045 PyObject * obj1 = 0 ;
31046 PyObject * obj2 = 0 ;
31047 char * kwnames[] = {
31048 (char *) "self",(char *) "pt",(char *) "flags", NULL
31049 };
31050
31051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31053 if (!SWIG_IsOK(res1)) {
31054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31055 }
31056 arg1 = reinterpret_cast< wxWindow * >(argp1);
31057 {
31058 arg2 = &temp2;
31059 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31060 }
31061 if (obj2) {
31062 ecode3 = SWIG_AsVal_int(obj2, &val3);
31063 if (!SWIG_IsOK(ecode3)) {
31064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31065 }
31066 arg3 = static_cast< int >(val3);
31067 }
31068 {
31069 PyThreadState* __tstate = wxPyBeginAllowThreads();
31070 (arg1)->Move((wxPoint const &)*arg2,arg3);
31071 wxPyEndAllowThreads(__tstate);
31072 if (PyErr_Occurred()) SWIG_fail;
31073 }
31074 resultobj = SWIG_Py_Void();
31075 return resultobj;
31076 fail:
31077 return NULL;
31078 }
31079
31080
31081 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31082 PyObject *resultobj = 0;
31083 wxWindow *arg1 = (wxWindow *) 0 ;
31084 int arg2 ;
31085 int arg3 ;
31086 int arg4 = (int) wxSIZE_USE_EXISTING ;
31087 void *argp1 = 0 ;
31088 int res1 = 0 ;
31089 int val2 ;
31090 int ecode2 = 0 ;
31091 int val3 ;
31092 int ecode3 = 0 ;
31093 int val4 ;
31094 int ecode4 = 0 ;
31095 PyObject * obj0 = 0 ;
31096 PyObject * obj1 = 0 ;
31097 PyObject * obj2 = 0 ;
31098 PyObject * obj3 = 0 ;
31099 char * kwnames[] = {
31100 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31101 };
31102
31103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31105 if (!SWIG_IsOK(res1)) {
31106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31107 }
31108 arg1 = reinterpret_cast< wxWindow * >(argp1);
31109 ecode2 = SWIG_AsVal_int(obj1, &val2);
31110 if (!SWIG_IsOK(ecode2)) {
31111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31112 }
31113 arg2 = static_cast< int >(val2);
31114 ecode3 = SWIG_AsVal_int(obj2, &val3);
31115 if (!SWIG_IsOK(ecode3)) {
31116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31117 }
31118 arg3 = static_cast< int >(val3);
31119 if (obj3) {
31120 ecode4 = SWIG_AsVal_int(obj3, &val4);
31121 if (!SWIG_IsOK(ecode4)) {
31122 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31123 }
31124 arg4 = static_cast< int >(val4);
31125 }
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 (arg1)->Move(arg2,arg3,arg4);
31129 wxPyEndAllowThreads(__tstate);
31130 if (PyErr_Occurred()) SWIG_fail;
31131 }
31132 resultobj = SWIG_Py_Void();
31133 return resultobj;
31134 fail:
31135 return NULL;
31136 }
31137
31138
31139 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31140 PyObject *resultobj = 0;
31141 wxWindow *arg1 = (wxWindow *) 0 ;
31142 wxSize const &arg2_defvalue = wxDefaultSize ;
31143 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31144 void *argp1 = 0 ;
31145 int res1 = 0 ;
31146 wxSize temp2 ;
31147 PyObject * obj0 = 0 ;
31148 PyObject * obj1 = 0 ;
31149 char * kwnames[] = {
31150 (char *) "self",(char *) "size", NULL
31151 };
31152
31153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31155 if (!SWIG_IsOK(res1)) {
31156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31157 }
31158 arg1 = reinterpret_cast< wxWindow * >(argp1);
31159 if (obj1) {
31160 {
31161 arg2 = &temp2;
31162 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31163 }
31164 }
31165 {
31166 PyThreadState* __tstate = wxPyBeginAllowThreads();
31167 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31168 wxPyEndAllowThreads(__tstate);
31169 if (PyErr_Occurred()) SWIG_fail;
31170 }
31171 resultobj = SWIG_Py_Void();
31172 return resultobj;
31173 fail:
31174 return NULL;
31175 }
31176
31177
31178 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31179 PyObject *resultobj = 0;
31180 wxWindow *arg1 = (wxWindow *) 0 ;
31181 void *argp1 = 0 ;
31182 int res1 = 0 ;
31183 PyObject *swig_obj[1] ;
31184
31185 if (!args) SWIG_fail;
31186 swig_obj[0] = args;
31187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31188 if (!SWIG_IsOK(res1)) {
31189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31190 }
31191 arg1 = reinterpret_cast< wxWindow * >(argp1);
31192 {
31193 PyThreadState* __tstate = wxPyBeginAllowThreads();
31194 (arg1)->Raise();
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_Lower(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_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31217 }
31218 arg1 = reinterpret_cast< wxWindow * >(argp1);
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 (arg1)->Lower();
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_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31233 PyObject *resultobj = 0;
31234 wxWindow *arg1 = (wxWindow *) 0 ;
31235 wxSize *arg2 = 0 ;
31236 void *argp1 = 0 ;
31237 int res1 = 0 ;
31238 wxSize temp2 ;
31239 PyObject * obj0 = 0 ;
31240 PyObject * obj1 = 0 ;
31241 char * kwnames[] = {
31242 (char *) "self",(char *) "size", NULL
31243 };
31244
31245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31247 if (!SWIG_IsOK(res1)) {
31248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31249 }
31250 arg1 = reinterpret_cast< wxWindow * >(argp1);
31251 {
31252 arg2 = &temp2;
31253 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31254 }
31255 {
31256 PyThreadState* __tstate = wxPyBeginAllowThreads();
31257 (arg1)->SetClientSize((wxSize const &)*arg2);
31258 wxPyEndAllowThreads(__tstate);
31259 if (PyErr_Occurred()) SWIG_fail;
31260 }
31261 resultobj = SWIG_Py_Void();
31262 return resultobj;
31263 fail:
31264 return NULL;
31265 }
31266
31267
31268 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31269 PyObject *resultobj = 0;
31270 wxWindow *arg1 = (wxWindow *) 0 ;
31271 int arg2 ;
31272 int arg3 ;
31273 void *argp1 = 0 ;
31274 int res1 = 0 ;
31275 int val2 ;
31276 int ecode2 = 0 ;
31277 int val3 ;
31278 int ecode3 = 0 ;
31279 PyObject * obj0 = 0 ;
31280 PyObject * obj1 = 0 ;
31281 PyObject * obj2 = 0 ;
31282 char * kwnames[] = {
31283 (char *) "self",(char *) "width",(char *) "height", NULL
31284 };
31285
31286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31288 if (!SWIG_IsOK(res1)) {
31289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31290 }
31291 arg1 = reinterpret_cast< wxWindow * >(argp1);
31292 ecode2 = SWIG_AsVal_int(obj1, &val2);
31293 if (!SWIG_IsOK(ecode2)) {
31294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31295 }
31296 arg2 = static_cast< int >(val2);
31297 ecode3 = SWIG_AsVal_int(obj2, &val3);
31298 if (!SWIG_IsOK(ecode3)) {
31299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31300 }
31301 arg3 = static_cast< int >(val3);
31302 {
31303 PyThreadState* __tstate = wxPyBeginAllowThreads();
31304 (arg1)->SetClientSize(arg2,arg3);
31305 wxPyEndAllowThreads(__tstate);
31306 if (PyErr_Occurred()) SWIG_fail;
31307 }
31308 resultobj = SWIG_Py_Void();
31309 return resultobj;
31310 fail:
31311 return NULL;
31312 }
31313
31314
31315 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31316 PyObject *resultobj = 0;
31317 wxWindow *arg1 = (wxWindow *) 0 ;
31318 wxRect *arg2 = 0 ;
31319 void *argp1 = 0 ;
31320 int res1 = 0 ;
31321 wxRect temp2 ;
31322 PyObject * obj0 = 0 ;
31323 PyObject * obj1 = 0 ;
31324 char * kwnames[] = {
31325 (char *) "self",(char *) "rect", NULL
31326 };
31327
31328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31330 if (!SWIG_IsOK(res1)) {
31331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31332 }
31333 arg1 = reinterpret_cast< wxWindow * >(argp1);
31334 {
31335 arg2 = &temp2;
31336 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31337 }
31338 {
31339 PyThreadState* __tstate = wxPyBeginAllowThreads();
31340 (arg1)->SetClientSize((wxRect const &)*arg2);
31341 wxPyEndAllowThreads(__tstate);
31342 if (PyErr_Occurred()) SWIG_fail;
31343 }
31344 resultobj = SWIG_Py_Void();
31345 return resultobj;
31346 fail:
31347 return NULL;
31348 }
31349
31350
31351 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31352 PyObject *resultobj = 0;
31353 wxWindow *arg1 = (wxWindow *) 0 ;
31354 wxPoint result;
31355 void *argp1 = 0 ;
31356 int res1 = 0 ;
31357 PyObject *swig_obj[1] ;
31358
31359 if (!args) SWIG_fail;
31360 swig_obj[0] = args;
31361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31362 if (!SWIG_IsOK(res1)) {
31363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31364 }
31365 arg1 = reinterpret_cast< wxWindow * >(argp1);
31366 {
31367 PyThreadState* __tstate = wxPyBeginAllowThreads();
31368 result = ((wxWindow const *)arg1)->GetPosition();
31369 wxPyEndAllowThreads(__tstate);
31370 if (PyErr_Occurred()) SWIG_fail;
31371 }
31372 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31373 return resultobj;
31374 fail:
31375 return NULL;
31376 }
31377
31378
31379 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31380 PyObject *resultobj = 0;
31381 wxWindow *arg1 = (wxWindow *) 0 ;
31382 int *arg2 = (int *) 0 ;
31383 int *arg3 = (int *) 0 ;
31384 void *argp1 = 0 ;
31385 int res1 = 0 ;
31386 int temp2 ;
31387 int res2 = SWIG_TMPOBJ ;
31388 int temp3 ;
31389 int res3 = SWIG_TMPOBJ ;
31390 PyObject *swig_obj[1] ;
31391
31392 arg2 = &temp2;
31393 arg3 = &temp3;
31394 if (!args) SWIG_fail;
31395 swig_obj[0] = args;
31396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31397 if (!SWIG_IsOK(res1)) {
31398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31399 }
31400 arg1 = reinterpret_cast< wxWindow * >(argp1);
31401 {
31402 PyThreadState* __tstate = wxPyBeginAllowThreads();
31403 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31404 wxPyEndAllowThreads(__tstate);
31405 if (PyErr_Occurred()) SWIG_fail;
31406 }
31407 resultobj = SWIG_Py_Void();
31408 if (SWIG_IsTmpObj(res2)) {
31409 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31410 } else {
31411 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31412 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31413 }
31414 if (SWIG_IsTmpObj(res3)) {
31415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31416 } else {
31417 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31419 }
31420 return resultobj;
31421 fail:
31422 return NULL;
31423 }
31424
31425
31426 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31427 PyObject *resultobj = 0;
31428 wxWindow *arg1 = (wxWindow *) 0 ;
31429 wxPoint result;
31430 void *argp1 = 0 ;
31431 int res1 = 0 ;
31432 PyObject *swig_obj[1] ;
31433
31434 if (!args) SWIG_fail;
31435 swig_obj[0] = args;
31436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31437 if (!SWIG_IsOK(res1)) {
31438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31439 }
31440 arg1 = reinterpret_cast< wxWindow * >(argp1);
31441 {
31442 PyThreadState* __tstate = wxPyBeginAllowThreads();
31443 result = ((wxWindow const *)arg1)->GetScreenPosition();
31444 wxPyEndAllowThreads(__tstate);
31445 if (PyErr_Occurred()) SWIG_fail;
31446 }
31447 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31448 return resultobj;
31449 fail:
31450 return NULL;
31451 }
31452
31453
31454 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31455 PyObject *resultobj = 0;
31456 wxWindow *arg1 = (wxWindow *) 0 ;
31457 int *arg2 = (int *) 0 ;
31458 int *arg3 = (int *) 0 ;
31459 void *argp1 = 0 ;
31460 int res1 = 0 ;
31461 int temp2 ;
31462 int res2 = SWIG_TMPOBJ ;
31463 int temp3 ;
31464 int res3 = SWIG_TMPOBJ ;
31465 PyObject *swig_obj[1] ;
31466
31467 arg2 = &temp2;
31468 arg3 = &temp3;
31469 if (!args) SWIG_fail;
31470 swig_obj[0] = args;
31471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31472 if (!SWIG_IsOK(res1)) {
31473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31474 }
31475 arg1 = reinterpret_cast< wxWindow * >(argp1);
31476 {
31477 PyThreadState* __tstate = wxPyBeginAllowThreads();
31478 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31479 wxPyEndAllowThreads(__tstate);
31480 if (PyErr_Occurred()) SWIG_fail;
31481 }
31482 resultobj = SWIG_Py_Void();
31483 if (SWIG_IsTmpObj(res2)) {
31484 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31485 } else {
31486 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31488 }
31489 if (SWIG_IsTmpObj(res3)) {
31490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31491 } else {
31492 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31494 }
31495 return resultobj;
31496 fail:
31497 return NULL;
31498 }
31499
31500
31501 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31502 PyObject *resultobj = 0;
31503 wxWindow *arg1 = (wxWindow *) 0 ;
31504 wxRect result;
31505 void *argp1 = 0 ;
31506 int res1 = 0 ;
31507 PyObject *swig_obj[1] ;
31508
31509 if (!args) SWIG_fail;
31510 swig_obj[0] = args;
31511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31512 if (!SWIG_IsOK(res1)) {
31513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31514 }
31515 arg1 = reinterpret_cast< wxWindow * >(argp1);
31516 {
31517 PyThreadState* __tstate = wxPyBeginAllowThreads();
31518 result = ((wxWindow const *)arg1)->GetScreenRect();
31519 wxPyEndAllowThreads(__tstate);
31520 if (PyErr_Occurred()) SWIG_fail;
31521 }
31522 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31523 return resultobj;
31524 fail:
31525 return NULL;
31526 }
31527
31528
31529 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31530 PyObject *resultobj = 0;
31531 wxWindow *arg1 = (wxWindow *) 0 ;
31532 wxSize result;
31533 void *argp1 = 0 ;
31534 int res1 = 0 ;
31535 PyObject *swig_obj[1] ;
31536
31537 if (!args) SWIG_fail;
31538 swig_obj[0] = args;
31539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31540 if (!SWIG_IsOK(res1)) {
31541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31542 }
31543 arg1 = reinterpret_cast< wxWindow * >(argp1);
31544 {
31545 PyThreadState* __tstate = wxPyBeginAllowThreads();
31546 result = ((wxWindow const *)arg1)->GetSize();
31547 wxPyEndAllowThreads(__tstate);
31548 if (PyErr_Occurred()) SWIG_fail;
31549 }
31550 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31551 return resultobj;
31552 fail:
31553 return NULL;
31554 }
31555
31556
31557 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31558 PyObject *resultobj = 0;
31559 wxWindow *arg1 = (wxWindow *) 0 ;
31560 int *arg2 = (int *) 0 ;
31561 int *arg3 = (int *) 0 ;
31562 void *argp1 = 0 ;
31563 int res1 = 0 ;
31564 int temp2 ;
31565 int res2 = SWIG_TMPOBJ ;
31566 int temp3 ;
31567 int res3 = SWIG_TMPOBJ ;
31568 PyObject *swig_obj[1] ;
31569
31570 arg2 = &temp2;
31571 arg3 = &temp3;
31572 if (!args) SWIG_fail;
31573 swig_obj[0] = args;
31574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31575 if (!SWIG_IsOK(res1)) {
31576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31577 }
31578 arg1 = reinterpret_cast< wxWindow * >(argp1);
31579 {
31580 PyThreadState* __tstate = wxPyBeginAllowThreads();
31581 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31582 wxPyEndAllowThreads(__tstate);
31583 if (PyErr_Occurred()) SWIG_fail;
31584 }
31585 resultobj = SWIG_Py_Void();
31586 if (SWIG_IsTmpObj(res2)) {
31587 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31588 } else {
31589 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31590 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31591 }
31592 if (SWIG_IsTmpObj(res3)) {
31593 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31594 } else {
31595 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31597 }
31598 return resultobj;
31599 fail:
31600 return NULL;
31601 }
31602
31603
31604 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31605 PyObject *resultobj = 0;
31606 wxWindow *arg1 = (wxWindow *) 0 ;
31607 wxRect result;
31608 void *argp1 = 0 ;
31609 int res1 = 0 ;
31610 PyObject *swig_obj[1] ;
31611
31612 if (!args) SWIG_fail;
31613 swig_obj[0] = args;
31614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31615 if (!SWIG_IsOK(res1)) {
31616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31617 }
31618 arg1 = reinterpret_cast< wxWindow * >(argp1);
31619 {
31620 PyThreadState* __tstate = wxPyBeginAllowThreads();
31621 result = ((wxWindow const *)arg1)->GetRect();
31622 wxPyEndAllowThreads(__tstate);
31623 if (PyErr_Occurred()) SWIG_fail;
31624 }
31625 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31626 return resultobj;
31627 fail:
31628 return NULL;
31629 }
31630
31631
31632 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31633 PyObject *resultobj = 0;
31634 wxWindow *arg1 = (wxWindow *) 0 ;
31635 wxSize result;
31636 void *argp1 = 0 ;
31637 int res1 = 0 ;
31638 PyObject *swig_obj[1] ;
31639
31640 if (!args) SWIG_fail;
31641 swig_obj[0] = args;
31642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31643 if (!SWIG_IsOK(res1)) {
31644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31645 }
31646 arg1 = reinterpret_cast< wxWindow * >(argp1);
31647 {
31648 PyThreadState* __tstate = wxPyBeginAllowThreads();
31649 result = ((wxWindow const *)arg1)->GetClientSize();
31650 wxPyEndAllowThreads(__tstate);
31651 if (PyErr_Occurred()) SWIG_fail;
31652 }
31653 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31654 return resultobj;
31655 fail:
31656 return NULL;
31657 }
31658
31659
31660 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31661 PyObject *resultobj = 0;
31662 wxWindow *arg1 = (wxWindow *) 0 ;
31663 int *arg2 = (int *) 0 ;
31664 int *arg3 = (int *) 0 ;
31665 void *argp1 = 0 ;
31666 int res1 = 0 ;
31667 int temp2 ;
31668 int res2 = SWIG_TMPOBJ ;
31669 int temp3 ;
31670 int res3 = SWIG_TMPOBJ ;
31671 PyObject *swig_obj[1] ;
31672
31673 arg2 = &temp2;
31674 arg3 = &temp3;
31675 if (!args) SWIG_fail;
31676 swig_obj[0] = args;
31677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31678 if (!SWIG_IsOK(res1)) {
31679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31680 }
31681 arg1 = reinterpret_cast< wxWindow * >(argp1);
31682 {
31683 PyThreadState* __tstate = wxPyBeginAllowThreads();
31684 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31685 wxPyEndAllowThreads(__tstate);
31686 if (PyErr_Occurred()) SWIG_fail;
31687 }
31688 resultobj = SWIG_Py_Void();
31689 if (SWIG_IsTmpObj(res2)) {
31690 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31691 } else {
31692 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31693 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31694 }
31695 if (SWIG_IsTmpObj(res3)) {
31696 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31697 } else {
31698 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31699 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31700 }
31701 return resultobj;
31702 fail:
31703 return NULL;
31704 }
31705
31706
31707 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31708 PyObject *resultobj = 0;
31709 wxWindow *arg1 = (wxWindow *) 0 ;
31710 wxPoint result;
31711 void *argp1 = 0 ;
31712 int res1 = 0 ;
31713 PyObject *swig_obj[1] ;
31714
31715 if (!args) SWIG_fail;
31716 swig_obj[0] = args;
31717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31718 if (!SWIG_IsOK(res1)) {
31719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31720 }
31721 arg1 = reinterpret_cast< wxWindow * >(argp1);
31722 {
31723 PyThreadState* __tstate = wxPyBeginAllowThreads();
31724 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31725 wxPyEndAllowThreads(__tstate);
31726 if (PyErr_Occurred()) SWIG_fail;
31727 }
31728 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31729 return resultobj;
31730 fail:
31731 return NULL;
31732 }
31733
31734
31735 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31736 PyObject *resultobj = 0;
31737 wxWindow *arg1 = (wxWindow *) 0 ;
31738 wxRect result;
31739 void *argp1 = 0 ;
31740 int res1 = 0 ;
31741 PyObject *swig_obj[1] ;
31742
31743 if (!args) SWIG_fail;
31744 swig_obj[0] = args;
31745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31746 if (!SWIG_IsOK(res1)) {
31747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31748 }
31749 arg1 = reinterpret_cast< wxWindow * >(argp1);
31750 {
31751 PyThreadState* __tstate = wxPyBeginAllowThreads();
31752 result = ((wxWindow const *)arg1)->GetClientRect();
31753 wxPyEndAllowThreads(__tstate);
31754 if (PyErr_Occurred()) SWIG_fail;
31755 }
31756 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31757 return resultobj;
31758 fail:
31759 return NULL;
31760 }
31761
31762
31763 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31764 PyObject *resultobj = 0;
31765 wxWindow *arg1 = (wxWindow *) 0 ;
31766 wxSize result;
31767 void *argp1 = 0 ;
31768 int res1 = 0 ;
31769 PyObject *swig_obj[1] ;
31770
31771 if (!args) SWIG_fail;
31772 swig_obj[0] = args;
31773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31774 if (!SWIG_IsOK(res1)) {
31775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31776 }
31777 arg1 = reinterpret_cast< wxWindow * >(argp1);
31778 {
31779 PyThreadState* __tstate = wxPyBeginAllowThreads();
31780 result = ((wxWindow const *)arg1)->GetBestSize();
31781 wxPyEndAllowThreads(__tstate);
31782 if (PyErr_Occurred()) SWIG_fail;
31783 }
31784 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31785 return resultobj;
31786 fail:
31787 return NULL;
31788 }
31789
31790
31791 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31792 PyObject *resultobj = 0;
31793 wxWindow *arg1 = (wxWindow *) 0 ;
31794 int *arg2 = (int *) 0 ;
31795 int *arg3 = (int *) 0 ;
31796 void *argp1 = 0 ;
31797 int res1 = 0 ;
31798 int temp2 ;
31799 int res2 = SWIG_TMPOBJ ;
31800 int temp3 ;
31801 int res3 = SWIG_TMPOBJ ;
31802 PyObject *swig_obj[1] ;
31803
31804 arg2 = &temp2;
31805 arg3 = &temp3;
31806 if (!args) SWIG_fail;
31807 swig_obj[0] = args;
31808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31809 if (!SWIG_IsOK(res1)) {
31810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31811 }
31812 arg1 = reinterpret_cast< wxWindow * >(argp1);
31813 {
31814 PyThreadState* __tstate = wxPyBeginAllowThreads();
31815 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31816 wxPyEndAllowThreads(__tstate);
31817 if (PyErr_Occurred()) SWIG_fail;
31818 }
31819 resultobj = SWIG_Py_Void();
31820 if (SWIG_IsTmpObj(res2)) {
31821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31822 } else {
31823 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31825 }
31826 if (SWIG_IsTmpObj(res3)) {
31827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31828 } else {
31829 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31831 }
31832 return resultobj;
31833 fail:
31834 return NULL;
31835 }
31836
31837
31838 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31839 PyObject *resultobj = 0;
31840 wxWindow *arg1 = (wxWindow *) 0 ;
31841 void *argp1 = 0 ;
31842 int res1 = 0 ;
31843 PyObject *swig_obj[1] ;
31844
31845 if (!args) SWIG_fail;
31846 swig_obj[0] = args;
31847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31848 if (!SWIG_IsOK(res1)) {
31849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31850 }
31851 arg1 = reinterpret_cast< wxWindow * >(argp1);
31852 {
31853 PyThreadState* __tstate = wxPyBeginAllowThreads();
31854 (arg1)->InvalidateBestSize();
31855 wxPyEndAllowThreads(__tstate);
31856 if (PyErr_Occurred()) SWIG_fail;
31857 }
31858 resultobj = SWIG_Py_Void();
31859 return resultobj;
31860 fail:
31861 return NULL;
31862 }
31863
31864
31865 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31866 PyObject *resultobj = 0;
31867 wxWindow *arg1 = (wxWindow *) 0 ;
31868 wxSize *arg2 = 0 ;
31869 void *argp1 = 0 ;
31870 int res1 = 0 ;
31871 wxSize temp2 ;
31872 PyObject * obj0 = 0 ;
31873 PyObject * obj1 = 0 ;
31874 char * kwnames[] = {
31875 (char *) "self",(char *) "size", NULL
31876 };
31877
31878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31880 if (!SWIG_IsOK(res1)) {
31881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31882 }
31883 arg1 = reinterpret_cast< wxWindow * >(argp1);
31884 {
31885 arg2 = &temp2;
31886 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31887 }
31888 {
31889 PyThreadState* __tstate = wxPyBeginAllowThreads();
31890 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31891 wxPyEndAllowThreads(__tstate);
31892 if (PyErr_Occurred()) SWIG_fail;
31893 }
31894 resultobj = SWIG_Py_Void();
31895 return resultobj;
31896 fail:
31897 return NULL;
31898 }
31899
31900
31901 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31902 PyObject *resultobj = 0;
31903 wxWindow *arg1 = (wxWindow *) 0 ;
31904 wxSize result;
31905 void *argp1 = 0 ;
31906 int res1 = 0 ;
31907 PyObject *swig_obj[1] ;
31908
31909 if (!args) SWIG_fail;
31910 swig_obj[0] = args;
31911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31912 if (!SWIG_IsOK(res1)) {
31913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31914 }
31915 arg1 = reinterpret_cast< wxWindow * >(argp1);
31916 {
31917 PyThreadState* __tstate = wxPyBeginAllowThreads();
31918 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31919 wxPyEndAllowThreads(__tstate);
31920 if (PyErr_Occurred()) SWIG_fail;
31921 }
31922 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31923 return resultobj;
31924 fail:
31925 return NULL;
31926 }
31927
31928
31929 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31930 PyObject *resultobj = 0;
31931 wxWindow *arg1 = (wxWindow *) 0 ;
31932 wxSize result;
31933 void *argp1 = 0 ;
31934 int res1 = 0 ;
31935 PyObject *swig_obj[1] ;
31936
31937 if (!args) SWIG_fail;
31938 swig_obj[0] = args;
31939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31940 if (!SWIG_IsOK(res1)) {
31941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31942 }
31943 arg1 = reinterpret_cast< wxWindow * >(argp1);
31944 {
31945 PyThreadState* __tstate = wxPyBeginAllowThreads();
31946 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31947 wxPyEndAllowThreads(__tstate);
31948 if (PyErr_Occurred()) SWIG_fail;
31949 }
31950 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31951 return resultobj;
31952 fail:
31953 return NULL;
31954 }
31955
31956
31957 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31958 PyObject *resultobj = 0;
31959 wxWindow *arg1 = (wxWindow *) 0 ;
31960 int arg2 = (int) wxBOTH ;
31961 void *argp1 = 0 ;
31962 int res1 = 0 ;
31963 int val2 ;
31964 int ecode2 = 0 ;
31965 PyObject * obj0 = 0 ;
31966 PyObject * obj1 = 0 ;
31967 char * kwnames[] = {
31968 (char *) "self",(char *) "direction", NULL
31969 };
31970
31971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31973 if (!SWIG_IsOK(res1)) {
31974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31975 }
31976 arg1 = reinterpret_cast< wxWindow * >(argp1);
31977 if (obj1) {
31978 ecode2 = SWIG_AsVal_int(obj1, &val2);
31979 if (!SWIG_IsOK(ecode2)) {
31980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31981 }
31982 arg2 = static_cast< int >(val2);
31983 }
31984 {
31985 PyThreadState* __tstate = wxPyBeginAllowThreads();
31986 (arg1)->Center(arg2);
31987 wxPyEndAllowThreads(__tstate);
31988 if (PyErr_Occurred()) SWIG_fail;
31989 }
31990 resultobj = SWIG_Py_Void();
31991 return resultobj;
31992 fail:
31993 return NULL;
31994 }
31995
31996
31997 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31998 PyObject *resultobj = 0;
31999 wxWindow *arg1 = (wxWindow *) 0 ;
32000 int arg2 = (int) wxBOTH ;
32001 void *argp1 = 0 ;
32002 int res1 = 0 ;
32003 int val2 ;
32004 int ecode2 = 0 ;
32005 PyObject * obj0 = 0 ;
32006 PyObject * obj1 = 0 ;
32007 char * kwnames[] = {
32008 (char *) "self",(char *) "dir", NULL
32009 };
32010
32011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32013 if (!SWIG_IsOK(res1)) {
32014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32015 }
32016 arg1 = reinterpret_cast< wxWindow * >(argp1);
32017 if (obj1) {
32018 ecode2 = SWIG_AsVal_int(obj1, &val2);
32019 if (!SWIG_IsOK(ecode2)) {
32020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32021 }
32022 arg2 = static_cast< int >(val2);
32023 }
32024 {
32025 PyThreadState* __tstate = wxPyBeginAllowThreads();
32026 (arg1)->CenterOnParent(arg2);
32027 wxPyEndAllowThreads(__tstate);
32028 if (PyErr_Occurred()) SWIG_fail;
32029 }
32030 resultobj = SWIG_Py_Void();
32031 return resultobj;
32032 fail:
32033 return NULL;
32034 }
32035
32036
32037 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32038 PyObject *resultobj = 0;
32039 wxWindow *arg1 = (wxWindow *) 0 ;
32040 void *argp1 = 0 ;
32041 int res1 = 0 ;
32042 PyObject *swig_obj[1] ;
32043
32044 if (!args) SWIG_fail;
32045 swig_obj[0] = args;
32046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32047 if (!SWIG_IsOK(res1)) {
32048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32049 }
32050 arg1 = reinterpret_cast< wxWindow * >(argp1);
32051 {
32052 PyThreadState* __tstate = wxPyBeginAllowThreads();
32053 (arg1)->Fit();
32054 wxPyEndAllowThreads(__tstate);
32055 if (PyErr_Occurred()) SWIG_fail;
32056 }
32057 resultobj = SWIG_Py_Void();
32058 return resultobj;
32059 fail:
32060 return NULL;
32061 }
32062
32063
32064 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32065 PyObject *resultobj = 0;
32066 wxWindow *arg1 = (wxWindow *) 0 ;
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_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32076 }
32077 arg1 = reinterpret_cast< wxWindow * >(argp1);
32078 {
32079 PyThreadState* __tstate = wxPyBeginAllowThreads();
32080 (arg1)->FitInside();
32081 wxPyEndAllowThreads(__tstate);
32082 if (PyErr_Occurred()) SWIG_fail;
32083 }
32084 resultobj = SWIG_Py_Void();
32085 return resultobj;
32086 fail:
32087 return NULL;
32088 }
32089
32090
32091 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32092 PyObject *resultobj = 0;
32093 wxWindow *arg1 = (wxWindow *) 0 ;
32094 int arg2 ;
32095 int arg3 ;
32096 int arg4 = (int) -1 ;
32097 int arg5 = (int) -1 ;
32098 int arg6 = (int) -1 ;
32099 int arg7 = (int) -1 ;
32100 void *argp1 = 0 ;
32101 int res1 = 0 ;
32102 int val2 ;
32103 int ecode2 = 0 ;
32104 int val3 ;
32105 int ecode3 = 0 ;
32106 int val4 ;
32107 int ecode4 = 0 ;
32108 int val5 ;
32109 int ecode5 = 0 ;
32110 int val6 ;
32111 int ecode6 = 0 ;
32112 int val7 ;
32113 int ecode7 = 0 ;
32114 PyObject * obj0 = 0 ;
32115 PyObject * obj1 = 0 ;
32116 PyObject * obj2 = 0 ;
32117 PyObject * obj3 = 0 ;
32118 PyObject * obj4 = 0 ;
32119 PyObject * obj5 = 0 ;
32120 PyObject * obj6 = 0 ;
32121 char * kwnames[] = {
32122 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32123 };
32124
32125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32127 if (!SWIG_IsOK(res1)) {
32128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32129 }
32130 arg1 = reinterpret_cast< wxWindow * >(argp1);
32131 ecode2 = SWIG_AsVal_int(obj1, &val2);
32132 if (!SWIG_IsOK(ecode2)) {
32133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32134 }
32135 arg2 = static_cast< int >(val2);
32136 ecode3 = SWIG_AsVal_int(obj2, &val3);
32137 if (!SWIG_IsOK(ecode3)) {
32138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32139 }
32140 arg3 = static_cast< int >(val3);
32141 if (obj3) {
32142 ecode4 = SWIG_AsVal_int(obj3, &val4);
32143 if (!SWIG_IsOK(ecode4)) {
32144 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32145 }
32146 arg4 = static_cast< int >(val4);
32147 }
32148 if (obj4) {
32149 ecode5 = SWIG_AsVal_int(obj4, &val5);
32150 if (!SWIG_IsOK(ecode5)) {
32151 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32152 }
32153 arg5 = static_cast< int >(val5);
32154 }
32155 if (obj5) {
32156 ecode6 = SWIG_AsVal_int(obj5, &val6);
32157 if (!SWIG_IsOK(ecode6)) {
32158 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32159 }
32160 arg6 = static_cast< int >(val6);
32161 }
32162 if (obj6) {
32163 ecode7 = SWIG_AsVal_int(obj6, &val7);
32164 if (!SWIG_IsOK(ecode7)) {
32165 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32166 }
32167 arg7 = static_cast< int >(val7);
32168 }
32169 {
32170 PyThreadState* __tstate = wxPyBeginAllowThreads();
32171 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32172 wxPyEndAllowThreads(__tstate);
32173 if (PyErr_Occurred()) SWIG_fail;
32174 }
32175 resultobj = SWIG_Py_Void();
32176 return resultobj;
32177 fail:
32178 return NULL;
32179 }
32180
32181
32182 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32183 PyObject *resultobj = 0;
32184 wxWindow *arg1 = (wxWindow *) 0 ;
32185 wxSize *arg2 = 0 ;
32186 wxSize const &arg3_defvalue = wxDefaultSize ;
32187 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32188 wxSize const &arg4_defvalue = wxDefaultSize ;
32189 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32190 void *argp1 = 0 ;
32191 int res1 = 0 ;
32192 wxSize temp2 ;
32193 wxSize temp3 ;
32194 wxSize temp4 ;
32195 PyObject * obj0 = 0 ;
32196 PyObject * obj1 = 0 ;
32197 PyObject * obj2 = 0 ;
32198 PyObject * obj3 = 0 ;
32199 char * kwnames[] = {
32200 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32201 };
32202
32203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32205 if (!SWIG_IsOK(res1)) {
32206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32207 }
32208 arg1 = reinterpret_cast< wxWindow * >(argp1);
32209 {
32210 arg2 = &temp2;
32211 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32212 }
32213 if (obj2) {
32214 {
32215 arg3 = &temp3;
32216 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32217 }
32218 }
32219 if (obj3) {
32220 {
32221 arg4 = &temp4;
32222 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32223 }
32224 }
32225 {
32226 PyThreadState* __tstate = wxPyBeginAllowThreads();
32227 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32228 wxPyEndAllowThreads(__tstate);
32229 if (PyErr_Occurred()) SWIG_fail;
32230 }
32231 resultobj = SWIG_Py_Void();
32232 return resultobj;
32233 fail:
32234 return NULL;
32235 }
32236
32237
32238 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32239 PyObject *resultobj = 0;
32240 wxWindow *arg1 = (wxWindow *) 0 ;
32241 int arg2 ;
32242 int arg3 ;
32243 int arg4 = (int) -1 ;
32244 int arg5 = (int) -1 ;
32245 void *argp1 = 0 ;
32246 int res1 = 0 ;
32247 int val2 ;
32248 int ecode2 = 0 ;
32249 int val3 ;
32250 int ecode3 = 0 ;
32251 int val4 ;
32252 int ecode4 = 0 ;
32253 int val5 ;
32254 int ecode5 = 0 ;
32255 PyObject * obj0 = 0 ;
32256 PyObject * obj1 = 0 ;
32257 PyObject * obj2 = 0 ;
32258 PyObject * obj3 = 0 ;
32259 PyObject * obj4 = 0 ;
32260 char * kwnames[] = {
32261 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32262 };
32263
32264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32266 if (!SWIG_IsOK(res1)) {
32267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32268 }
32269 arg1 = reinterpret_cast< wxWindow * >(argp1);
32270 ecode2 = SWIG_AsVal_int(obj1, &val2);
32271 if (!SWIG_IsOK(ecode2)) {
32272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32273 }
32274 arg2 = static_cast< int >(val2);
32275 ecode3 = SWIG_AsVal_int(obj2, &val3);
32276 if (!SWIG_IsOK(ecode3)) {
32277 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32278 }
32279 arg3 = static_cast< int >(val3);
32280 if (obj3) {
32281 ecode4 = SWIG_AsVal_int(obj3, &val4);
32282 if (!SWIG_IsOK(ecode4)) {
32283 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32284 }
32285 arg4 = static_cast< int >(val4);
32286 }
32287 if (obj4) {
32288 ecode5 = SWIG_AsVal_int(obj4, &val5);
32289 if (!SWIG_IsOK(ecode5)) {
32290 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32291 }
32292 arg5 = static_cast< int >(val5);
32293 }
32294 {
32295 PyThreadState* __tstate = wxPyBeginAllowThreads();
32296 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32297 wxPyEndAllowThreads(__tstate);
32298 if (PyErr_Occurred()) SWIG_fail;
32299 }
32300 resultobj = SWIG_Py_Void();
32301 return resultobj;
32302 fail:
32303 return NULL;
32304 }
32305
32306
32307 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32308 PyObject *resultobj = 0;
32309 wxWindow *arg1 = (wxWindow *) 0 ;
32310 wxSize *arg2 = 0 ;
32311 wxSize const &arg3_defvalue = wxDefaultSize ;
32312 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32313 void *argp1 = 0 ;
32314 int res1 = 0 ;
32315 wxSize temp2 ;
32316 wxSize temp3 ;
32317 PyObject * obj0 = 0 ;
32318 PyObject * obj1 = 0 ;
32319 PyObject * obj2 = 0 ;
32320 char * kwnames[] = {
32321 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32322 };
32323
32324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32326 if (!SWIG_IsOK(res1)) {
32327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32328 }
32329 arg1 = reinterpret_cast< wxWindow * >(argp1);
32330 {
32331 arg2 = &temp2;
32332 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32333 }
32334 if (obj2) {
32335 {
32336 arg3 = &temp3;
32337 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32338 }
32339 }
32340 {
32341 PyThreadState* __tstate = wxPyBeginAllowThreads();
32342 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32343 wxPyEndAllowThreads(__tstate);
32344 if (PyErr_Occurred()) SWIG_fail;
32345 }
32346 resultobj = SWIG_Py_Void();
32347 return resultobj;
32348 fail:
32349 return NULL;
32350 }
32351
32352
32353 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32354 PyObject *resultobj = 0;
32355 wxWindow *arg1 = (wxWindow *) 0 ;
32356 wxSize result;
32357 void *argp1 = 0 ;
32358 int res1 = 0 ;
32359 PyObject *swig_obj[1] ;
32360
32361 if (!args) SWIG_fail;
32362 swig_obj[0] = args;
32363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32364 if (!SWIG_IsOK(res1)) {
32365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32366 }
32367 arg1 = reinterpret_cast< wxWindow * >(argp1);
32368 {
32369 PyThreadState* __tstate = wxPyBeginAllowThreads();
32370 result = ((wxWindow const *)arg1)->GetMaxSize();
32371 wxPyEndAllowThreads(__tstate);
32372 if (PyErr_Occurred()) SWIG_fail;
32373 }
32374 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32375 return resultobj;
32376 fail:
32377 return NULL;
32378 }
32379
32380
32381 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32382 PyObject *resultobj = 0;
32383 wxWindow *arg1 = (wxWindow *) 0 ;
32384 wxSize result;
32385 void *argp1 = 0 ;
32386 int res1 = 0 ;
32387 PyObject *swig_obj[1] ;
32388
32389 if (!args) SWIG_fail;
32390 swig_obj[0] = args;
32391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32392 if (!SWIG_IsOK(res1)) {
32393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32394 }
32395 arg1 = reinterpret_cast< wxWindow * >(argp1);
32396 {
32397 PyThreadState* __tstate = wxPyBeginAllowThreads();
32398 result = ((wxWindow const *)arg1)->GetMinSize();
32399 wxPyEndAllowThreads(__tstate);
32400 if (PyErr_Occurred()) SWIG_fail;
32401 }
32402 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32403 return resultobj;
32404 fail:
32405 return NULL;
32406 }
32407
32408
32409 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32410 PyObject *resultobj = 0;
32411 wxWindow *arg1 = (wxWindow *) 0 ;
32412 wxSize *arg2 = 0 ;
32413 void *argp1 = 0 ;
32414 int res1 = 0 ;
32415 wxSize temp2 ;
32416 PyObject * obj0 = 0 ;
32417 PyObject * obj1 = 0 ;
32418 char * kwnames[] = {
32419 (char *) "self",(char *) "minSize", NULL
32420 };
32421
32422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32424 if (!SWIG_IsOK(res1)) {
32425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32426 }
32427 arg1 = reinterpret_cast< wxWindow * >(argp1);
32428 {
32429 arg2 = &temp2;
32430 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32431 }
32432 {
32433 PyThreadState* __tstate = wxPyBeginAllowThreads();
32434 (arg1)->SetMinSize((wxSize const &)*arg2);
32435 wxPyEndAllowThreads(__tstate);
32436 if (PyErr_Occurred()) SWIG_fail;
32437 }
32438 resultobj = SWIG_Py_Void();
32439 return resultobj;
32440 fail:
32441 return NULL;
32442 }
32443
32444
32445 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32446 PyObject *resultobj = 0;
32447 wxWindow *arg1 = (wxWindow *) 0 ;
32448 wxSize *arg2 = 0 ;
32449 void *argp1 = 0 ;
32450 int res1 = 0 ;
32451 wxSize temp2 ;
32452 PyObject * obj0 = 0 ;
32453 PyObject * obj1 = 0 ;
32454 char * kwnames[] = {
32455 (char *) "self",(char *) "maxSize", NULL
32456 };
32457
32458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32460 if (!SWIG_IsOK(res1)) {
32461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32462 }
32463 arg1 = reinterpret_cast< wxWindow * >(argp1);
32464 {
32465 arg2 = &temp2;
32466 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32467 }
32468 {
32469 PyThreadState* __tstate = wxPyBeginAllowThreads();
32470 (arg1)->SetMaxSize((wxSize const &)*arg2);
32471 wxPyEndAllowThreads(__tstate);
32472 if (PyErr_Occurred()) SWIG_fail;
32473 }
32474 resultobj = SWIG_Py_Void();
32475 return resultobj;
32476 fail:
32477 return NULL;
32478 }
32479
32480
32481 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32482 PyObject *resultobj = 0;
32483 wxWindow *arg1 = (wxWindow *) 0 ;
32484 int result;
32485 void *argp1 = 0 ;
32486 int res1 = 0 ;
32487 PyObject *swig_obj[1] ;
32488
32489 if (!args) SWIG_fail;
32490 swig_obj[0] = args;
32491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32492 if (!SWIG_IsOK(res1)) {
32493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32494 }
32495 arg1 = reinterpret_cast< wxWindow * >(argp1);
32496 {
32497 PyThreadState* __tstate = wxPyBeginAllowThreads();
32498 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32499 wxPyEndAllowThreads(__tstate);
32500 if (PyErr_Occurred()) SWIG_fail;
32501 }
32502 resultobj = SWIG_From_int(static_cast< int >(result));
32503 return resultobj;
32504 fail:
32505 return NULL;
32506 }
32507
32508
32509 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32510 PyObject *resultobj = 0;
32511 wxWindow *arg1 = (wxWindow *) 0 ;
32512 int result;
32513 void *argp1 = 0 ;
32514 int res1 = 0 ;
32515 PyObject *swig_obj[1] ;
32516
32517 if (!args) SWIG_fail;
32518 swig_obj[0] = args;
32519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32520 if (!SWIG_IsOK(res1)) {
32521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32522 }
32523 arg1 = reinterpret_cast< wxWindow * >(argp1);
32524 {
32525 PyThreadState* __tstate = wxPyBeginAllowThreads();
32526 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32527 wxPyEndAllowThreads(__tstate);
32528 if (PyErr_Occurred()) SWIG_fail;
32529 }
32530 resultobj = SWIG_From_int(static_cast< int >(result));
32531 return resultobj;
32532 fail:
32533 return NULL;
32534 }
32535
32536
32537 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32538 PyObject *resultobj = 0;
32539 wxWindow *arg1 = (wxWindow *) 0 ;
32540 int result;
32541 void *argp1 = 0 ;
32542 int res1 = 0 ;
32543 PyObject *swig_obj[1] ;
32544
32545 if (!args) SWIG_fail;
32546 swig_obj[0] = args;
32547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32548 if (!SWIG_IsOK(res1)) {
32549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32550 }
32551 arg1 = reinterpret_cast< wxWindow * >(argp1);
32552 {
32553 PyThreadState* __tstate = wxPyBeginAllowThreads();
32554 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32555 wxPyEndAllowThreads(__tstate);
32556 if (PyErr_Occurred()) SWIG_fail;
32557 }
32558 resultobj = SWIG_From_int(static_cast< int >(result));
32559 return resultobj;
32560 fail:
32561 return NULL;
32562 }
32563
32564
32565 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32566 PyObject *resultobj = 0;
32567 wxWindow *arg1 = (wxWindow *) 0 ;
32568 int result;
32569 void *argp1 = 0 ;
32570 int res1 = 0 ;
32571 PyObject *swig_obj[1] ;
32572
32573 if (!args) SWIG_fail;
32574 swig_obj[0] = args;
32575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32576 if (!SWIG_IsOK(res1)) {
32577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32578 }
32579 arg1 = reinterpret_cast< wxWindow * >(argp1);
32580 {
32581 PyThreadState* __tstate = wxPyBeginAllowThreads();
32582 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32583 wxPyEndAllowThreads(__tstate);
32584 if (PyErr_Occurred()) SWIG_fail;
32585 }
32586 resultobj = SWIG_From_int(static_cast< int >(result));
32587 return resultobj;
32588 fail:
32589 return NULL;
32590 }
32591
32592
32593 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32594 PyObject *resultobj = 0;
32595 wxWindow *arg1 = (wxWindow *) 0 ;
32596 wxSize *arg2 = 0 ;
32597 void *argp1 = 0 ;
32598 int res1 = 0 ;
32599 wxSize temp2 ;
32600 PyObject * obj0 = 0 ;
32601 PyObject * obj1 = 0 ;
32602 char * kwnames[] = {
32603 (char *) "self",(char *) "size", NULL
32604 };
32605
32606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32608 if (!SWIG_IsOK(res1)) {
32609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32610 }
32611 arg1 = reinterpret_cast< wxWindow * >(argp1);
32612 {
32613 arg2 = &temp2;
32614 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32615 }
32616 {
32617 PyThreadState* __tstate = wxPyBeginAllowThreads();
32618 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32619 wxPyEndAllowThreads(__tstate);
32620 if (PyErr_Occurred()) SWIG_fail;
32621 }
32622 resultobj = SWIG_Py_Void();
32623 return resultobj;
32624 fail:
32625 return NULL;
32626 }
32627
32628
32629 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32630 PyObject *resultobj = 0;
32631 wxWindow *arg1 = (wxWindow *) 0 ;
32632 int arg2 ;
32633 int arg3 ;
32634 void *argp1 = 0 ;
32635 int res1 = 0 ;
32636 int val2 ;
32637 int ecode2 = 0 ;
32638 int val3 ;
32639 int ecode3 = 0 ;
32640 PyObject * obj0 = 0 ;
32641 PyObject * obj1 = 0 ;
32642 PyObject * obj2 = 0 ;
32643 char * kwnames[] = {
32644 (char *) "self",(char *) "w",(char *) "h", NULL
32645 };
32646
32647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32649 if (!SWIG_IsOK(res1)) {
32650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32651 }
32652 arg1 = reinterpret_cast< wxWindow * >(argp1);
32653 ecode2 = SWIG_AsVal_int(obj1, &val2);
32654 if (!SWIG_IsOK(ecode2)) {
32655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32656 }
32657 arg2 = static_cast< int >(val2);
32658 ecode3 = SWIG_AsVal_int(obj2, &val3);
32659 if (!SWIG_IsOK(ecode3)) {
32660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32661 }
32662 arg3 = static_cast< int >(val3);
32663 {
32664 PyThreadState* __tstate = wxPyBeginAllowThreads();
32665 (arg1)->SetVirtualSize(arg2,arg3);
32666 wxPyEndAllowThreads(__tstate);
32667 if (PyErr_Occurred()) SWIG_fail;
32668 }
32669 resultobj = SWIG_Py_Void();
32670 return resultobj;
32671 fail:
32672 return NULL;
32673 }
32674
32675
32676 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32677 PyObject *resultobj = 0;
32678 wxWindow *arg1 = (wxWindow *) 0 ;
32679 wxSize result;
32680 void *argp1 = 0 ;
32681 int res1 = 0 ;
32682 PyObject *swig_obj[1] ;
32683
32684 if (!args) SWIG_fail;
32685 swig_obj[0] = args;
32686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32687 if (!SWIG_IsOK(res1)) {
32688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32689 }
32690 arg1 = reinterpret_cast< wxWindow * >(argp1);
32691 {
32692 PyThreadState* __tstate = wxPyBeginAllowThreads();
32693 result = ((wxWindow const *)arg1)->GetVirtualSize();
32694 wxPyEndAllowThreads(__tstate);
32695 if (PyErr_Occurred()) SWIG_fail;
32696 }
32697 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32698 return resultobj;
32699 fail:
32700 return NULL;
32701 }
32702
32703
32704 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32705 PyObject *resultobj = 0;
32706 wxWindow *arg1 = (wxWindow *) 0 ;
32707 int *arg2 = (int *) 0 ;
32708 int *arg3 = (int *) 0 ;
32709 void *argp1 = 0 ;
32710 int res1 = 0 ;
32711 int temp2 ;
32712 int res2 = SWIG_TMPOBJ ;
32713 int temp3 ;
32714 int res3 = SWIG_TMPOBJ ;
32715 PyObject *swig_obj[1] ;
32716
32717 arg2 = &temp2;
32718 arg3 = &temp3;
32719 if (!args) SWIG_fail;
32720 swig_obj[0] = args;
32721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32722 if (!SWIG_IsOK(res1)) {
32723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32724 }
32725 arg1 = reinterpret_cast< wxWindow * >(argp1);
32726 {
32727 PyThreadState* __tstate = wxPyBeginAllowThreads();
32728 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32729 wxPyEndAllowThreads(__tstate);
32730 if (PyErr_Occurred()) SWIG_fail;
32731 }
32732 resultobj = SWIG_Py_Void();
32733 if (SWIG_IsTmpObj(res2)) {
32734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32735 } else {
32736 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32738 }
32739 if (SWIG_IsTmpObj(res3)) {
32740 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32741 } else {
32742 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32743 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32744 }
32745 return resultobj;
32746 fail:
32747 return NULL;
32748 }
32749
32750
32751 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32752 PyObject *resultobj = 0;
32753 wxWindow *arg1 = (wxWindow *) 0 ;
32754 wxSize result;
32755 void *argp1 = 0 ;
32756 int res1 = 0 ;
32757 PyObject *swig_obj[1] ;
32758
32759 if (!args) SWIG_fail;
32760 swig_obj[0] = args;
32761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32762 if (!SWIG_IsOK(res1)) {
32763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32764 }
32765 arg1 = reinterpret_cast< wxWindow * >(argp1);
32766 {
32767 PyThreadState* __tstate = wxPyBeginAllowThreads();
32768 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32769 wxPyEndAllowThreads(__tstate);
32770 if (PyErr_Occurred()) SWIG_fail;
32771 }
32772 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32773 return resultobj;
32774 fail:
32775 return NULL;
32776 }
32777
32778
32779 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32780 PyObject *resultobj = 0;
32781 wxWindow *arg1 = (wxWindow *) 0 ;
32782 bool arg2 = (bool) true ;
32783 bool result;
32784 void *argp1 = 0 ;
32785 int res1 = 0 ;
32786 bool val2 ;
32787 int ecode2 = 0 ;
32788 PyObject * obj0 = 0 ;
32789 PyObject * obj1 = 0 ;
32790 char * kwnames[] = {
32791 (char *) "self",(char *) "show", NULL
32792 };
32793
32794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32796 if (!SWIG_IsOK(res1)) {
32797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32798 }
32799 arg1 = reinterpret_cast< wxWindow * >(argp1);
32800 if (obj1) {
32801 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32802 if (!SWIG_IsOK(ecode2)) {
32803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32804 }
32805 arg2 = static_cast< bool >(val2);
32806 }
32807 {
32808 PyThreadState* __tstate = wxPyBeginAllowThreads();
32809 result = (bool)(arg1)->Show(arg2);
32810 wxPyEndAllowThreads(__tstate);
32811 if (PyErr_Occurred()) SWIG_fail;
32812 }
32813 {
32814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32815 }
32816 return resultobj;
32817 fail:
32818 return NULL;
32819 }
32820
32821
32822 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32823 PyObject *resultobj = 0;
32824 wxWindow *arg1 = (wxWindow *) 0 ;
32825 bool result;
32826 void *argp1 = 0 ;
32827 int res1 = 0 ;
32828 PyObject *swig_obj[1] ;
32829
32830 if (!args) SWIG_fail;
32831 swig_obj[0] = args;
32832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32833 if (!SWIG_IsOK(res1)) {
32834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32835 }
32836 arg1 = reinterpret_cast< wxWindow * >(argp1);
32837 {
32838 PyThreadState* __tstate = wxPyBeginAllowThreads();
32839 result = (bool)(arg1)->Hide();
32840 wxPyEndAllowThreads(__tstate);
32841 if (PyErr_Occurred()) SWIG_fail;
32842 }
32843 {
32844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32845 }
32846 return resultobj;
32847 fail:
32848 return NULL;
32849 }
32850
32851
32852 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32853 PyObject *resultobj = 0;
32854 wxWindow *arg1 = (wxWindow *) 0 ;
32855 bool arg2 = (bool) true ;
32856 bool result;
32857 void *argp1 = 0 ;
32858 int res1 = 0 ;
32859 bool val2 ;
32860 int ecode2 = 0 ;
32861 PyObject * obj0 = 0 ;
32862 PyObject * obj1 = 0 ;
32863 char * kwnames[] = {
32864 (char *) "self",(char *) "enable", NULL
32865 };
32866
32867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32869 if (!SWIG_IsOK(res1)) {
32870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32871 }
32872 arg1 = reinterpret_cast< wxWindow * >(argp1);
32873 if (obj1) {
32874 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32875 if (!SWIG_IsOK(ecode2)) {
32876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32877 }
32878 arg2 = static_cast< bool >(val2);
32879 }
32880 {
32881 PyThreadState* __tstate = wxPyBeginAllowThreads();
32882 result = (bool)(arg1)->Enable(arg2);
32883 wxPyEndAllowThreads(__tstate);
32884 if (PyErr_Occurred()) SWIG_fail;
32885 }
32886 {
32887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32888 }
32889 return resultobj;
32890 fail:
32891 return NULL;
32892 }
32893
32894
32895 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32896 PyObject *resultobj = 0;
32897 wxWindow *arg1 = (wxWindow *) 0 ;
32898 bool result;
32899 void *argp1 = 0 ;
32900 int res1 = 0 ;
32901 PyObject *swig_obj[1] ;
32902
32903 if (!args) SWIG_fail;
32904 swig_obj[0] = args;
32905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32906 if (!SWIG_IsOK(res1)) {
32907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32908 }
32909 arg1 = reinterpret_cast< wxWindow * >(argp1);
32910 {
32911 PyThreadState* __tstate = wxPyBeginAllowThreads();
32912 result = (bool)(arg1)->Disable();
32913 wxPyEndAllowThreads(__tstate);
32914 if (PyErr_Occurred()) SWIG_fail;
32915 }
32916 {
32917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32918 }
32919 return resultobj;
32920 fail:
32921 return NULL;
32922 }
32923
32924
32925 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32926 PyObject *resultobj = 0;
32927 wxWindow *arg1 = (wxWindow *) 0 ;
32928 bool result;
32929 void *argp1 = 0 ;
32930 int res1 = 0 ;
32931 PyObject *swig_obj[1] ;
32932
32933 if (!args) SWIG_fail;
32934 swig_obj[0] = args;
32935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32936 if (!SWIG_IsOK(res1)) {
32937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32938 }
32939 arg1 = reinterpret_cast< wxWindow * >(argp1);
32940 {
32941 PyThreadState* __tstate = wxPyBeginAllowThreads();
32942 result = (bool)((wxWindow const *)arg1)->IsShown();
32943 wxPyEndAllowThreads(__tstate);
32944 if (PyErr_Occurred()) SWIG_fail;
32945 }
32946 {
32947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32948 }
32949 return resultobj;
32950 fail:
32951 return NULL;
32952 }
32953
32954
32955 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32956 PyObject *resultobj = 0;
32957 wxWindow *arg1 = (wxWindow *) 0 ;
32958 bool result;
32959 void *argp1 = 0 ;
32960 int res1 = 0 ;
32961 PyObject *swig_obj[1] ;
32962
32963 if (!args) SWIG_fail;
32964 swig_obj[0] = args;
32965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32966 if (!SWIG_IsOK(res1)) {
32967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32968 }
32969 arg1 = reinterpret_cast< wxWindow * >(argp1);
32970 {
32971 PyThreadState* __tstate = wxPyBeginAllowThreads();
32972 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32973 wxPyEndAllowThreads(__tstate);
32974 if (PyErr_Occurred()) SWIG_fail;
32975 }
32976 {
32977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32978 }
32979 return resultobj;
32980 fail:
32981 return NULL;
32982 }
32983
32984
32985 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32986 PyObject *resultobj = 0;
32987 wxWindow *arg1 = (wxWindow *) 0 ;
32988 bool result;
32989 void *argp1 = 0 ;
32990 int res1 = 0 ;
32991 PyObject *swig_obj[1] ;
32992
32993 if (!args) SWIG_fail;
32994 swig_obj[0] = args;
32995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32996 if (!SWIG_IsOK(res1)) {
32997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
32998 }
32999 arg1 = reinterpret_cast< wxWindow * >(argp1);
33000 {
33001 PyThreadState* __tstate = wxPyBeginAllowThreads();
33002 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33003 wxPyEndAllowThreads(__tstate);
33004 if (PyErr_Occurred()) SWIG_fail;
33005 }
33006 {
33007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33008 }
33009 return resultobj;
33010 fail:
33011 return NULL;
33012 }
33013
33014
33015 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33016 PyObject *resultobj = 0;
33017 wxWindow *arg1 = (wxWindow *) 0 ;
33018 long arg2 ;
33019 void *argp1 = 0 ;
33020 int res1 = 0 ;
33021 long val2 ;
33022 int ecode2 = 0 ;
33023 PyObject * obj0 = 0 ;
33024 PyObject * obj1 = 0 ;
33025 char * kwnames[] = {
33026 (char *) "self",(char *) "style", NULL
33027 };
33028
33029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33031 if (!SWIG_IsOK(res1)) {
33032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33033 }
33034 arg1 = reinterpret_cast< wxWindow * >(argp1);
33035 ecode2 = SWIG_AsVal_long(obj1, &val2);
33036 if (!SWIG_IsOK(ecode2)) {
33037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33038 }
33039 arg2 = static_cast< long >(val2);
33040 {
33041 PyThreadState* __tstate = wxPyBeginAllowThreads();
33042 (arg1)->SetWindowStyleFlag(arg2);
33043 wxPyEndAllowThreads(__tstate);
33044 if (PyErr_Occurred()) SWIG_fail;
33045 }
33046 resultobj = SWIG_Py_Void();
33047 return resultobj;
33048 fail:
33049 return NULL;
33050 }
33051
33052
33053 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33054 PyObject *resultobj = 0;
33055 wxWindow *arg1 = (wxWindow *) 0 ;
33056 long result;
33057 void *argp1 = 0 ;
33058 int res1 = 0 ;
33059 PyObject *swig_obj[1] ;
33060
33061 if (!args) SWIG_fail;
33062 swig_obj[0] = args;
33063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33064 if (!SWIG_IsOK(res1)) {
33065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33066 }
33067 arg1 = reinterpret_cast< wxWindow * >(argp1);
33068 {
33069 PyThreadState* __tstate = wxPyBeginAllowThreads();
33070 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33071 wxPyEndAllowThreads(__tstate);
33072 if (PyErr_Occurred()) SWIG_fail;
33073 }
33074 resultobj = SWIG_From_long(static_cast< long >(result));
33075 return resultobj;
33076 fail:
33077 return NULL;
33078 }
33079
33080
33081 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33082 PyObject *resultobj = 0;
33083 wxWindow *arg1 = (wxWindow *) 0 ;
33084 int arg2 ;
33085 bool result;
33086 void *argp1 = 0 ;
33087 int res1 = 0 ;
33088 int val2 ;
33089 int ecode2 = 0 ;
33090 PyObject * obj0 = 0 ;
33091 PyObject * obj1 = 0 ;
33092 char * kwnames[] = {
33093 (char *) "self",(char *) "flag", NULL
33094 };
33095
33096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33098 if (!SWIG_IsOK(res1)) {
33099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33100 }
33101 arg1 = reinterpret_cast< wxWindow * >(argp1);
33102 ecode2 = SWIG_AsVal_int(obj1, &val2);
33103 if (!SWIG_IsOK(ecode2)) {
33104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33105 }
33106 arg2 = static_cast< int >(val2);
33107 {
33108 PyThreadState* __tstate = wxPyBeginAllowThreads();
33109 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33110 wxPyEndAllowThreads(__tstate);
33111 if (PyErr_Occurred()) SWIG_fail;
33112 }
33113 {
33114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33115 }
33116 return resultobj;
33117 fail:
33118 return NULL;
33119 }
33120
33121
33122 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33123 PyObject *resultobj = 0;
33124 wxWindow *arg1 = (wxWindow *) 0 ;
33125 bool result;
33126 void *argp1 = 0 ;
33127 int res1 = 0 ;
33128 PyObject *swig_obj[1] ;
33129
33130 if (!args) SWIG_fail;
33131 swig_obj[0] = args;
33132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33133 if (!SWIG_IsOK(res1)) {
33134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33135 }
33136 arg1 = reinterpret_cast< wxWindow * >(argp1);
33137 {
33138 PyThreadState* __tstate = wxPyBeginAllowThreads();
33139 result = (bool)((wxWindow const *)arg1)->IsRetained();
33140 wxPyEndAllowThreads(__tstate);
33141 if (PyErr_Occurred()) SWIG_fail;
33142 }
33143 {
33144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33145 }
33146 return resultobj;
33147 fail:
33148 return NULL;
33149 }
33150
33151
33152 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33153 PyObject *resultobj = 0;
33154 wxWindow *arg1 = (wxWindow *) 0 ;
33155 long arg2 ;
33156 void *argp1 = 0 ;
33157 int res1 = 0 ;
33158 long val2 ;
33159 int ecode2 = 0 ;
33160 PyObject * obj0 = 0 ;
33161 PyObject * obj1 = 0 ;
33162 char * kwnames[] = {
33163 (char *) "self",(char *) "exStyle", NULL
33164 };
33165
33166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33168 if (!SWIG_IsOK(res1)) {
33169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33170 }
33171 arg1 = reinterpret_cast< wxWindow * >(argp1);
33172 ecode2 = SWIG_AsVal_long(obj1, &val2);
33173 if (!SWIG_IsOK(ecode2)) {
33174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33175 }
33176 arg2 = static_cast< long >(val2);
33177 {
33178 PyThreadState* __tstate = wxPyBeginAllowThreads();
33179 (arg1)->SetExtraStyle(arg2);
33180 wxPyEndAllowThreads(__tstate);
33181 if (PyErr_Occurred()) SWIG_fail;
33182 }
33183 resultobj = SWIG_Py_Void();
33184 return resultobj;
33185 fail:
33186 return NULL;
33187 }
33188
33189
33190 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33191 PyObject *resultobj = 0;
33192 wxWindow *arg1 = (wxWindow *) 0 ;
33193 long result;
33194 void *argp1 = 0 ;
33195 int res1 = 0 ;
33196 PyObject *swig_obj[1] ;
33197
33198 if (!args) SWIG_fail;
33199 swig_obj[0] = args;
33200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33201 if (!SWIG_IsOK(res1)) {
33202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33203 }
33204 arg1 = reinterpret_cast< wxWindow * >(argp1);
33205 {
33206 PyThreadState* __tstate = wxPyBeginAllowThreads();
33207 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33208 wxPyEndAllowThreads(__tstate);
33209 if (PyErr_Occurred()) SWIG_fail;
33210 }
33211 resultobj = SWIG_From_long(static_cast< long >(result));
33212 return resultobj;
33213 fail:
33214 return NULL;
33215 }
33216
33217
33218 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33219 PyObject *resultobj = 0;
33220 wxWindow *arg1 = (wxWindow *) 0 ;
33221 bool arg2 = (bool) true ;
33222 void *argp1 = 0 ;
33223 int res1 = 0 ;
33224 bool val2 ;
33225 int ecode2 = 0 ;
33226 PyObject * obj0 = 0 ;
33227 PyObject * obj1 = 0 ;
33228 char * kwnames[] = {
33229 (char *) "self",(char *) "modal", NULL
33230 };
33231
33232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33234 if (!SWIG_IsOK(res1)) {
33235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33236 }
33237 arg1 = reinterpret_cast< wxWindow * >(argp1);
33238 if (obj1) {
33239 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33240 if (!SWIG_IsOK(ecode2)) {
33241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33242 }
33243 arg2 = static_cast< bool >(val2);
33244 }
33245 {
33246 PyThreadState* __tstate = wxPyBeginAllowThreads();
33247 (arg1)->MakeModal(arg2);
33248 wxPyEndAllowThreads(__tstate);
33249 if (PyErr_Occurred()) SWIG_fail;
33250 }
33251 resultobj = SWIG_Py_Void();
33252 return resultobj;
33253 fail:
33254 return NULL;
33255 }
33256
33257
33258 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33259 PyObject *resultobj = 0;
33260 wxWindow *arg1 = (wxWindow *) 0 ;
33261 bool arg2 ;
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 *) "enableTheme", NULL
33270 };
33271
33272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",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_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33276 }
33277 arg1 = reinterpret_cast< wxWindow * >(argp1);
33278 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33279 if (!SWIG_IsOK(ecode2)) {
33280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33281 }
33282 arg2 = static_cast< bool >(val2);
33283 {
33284 PyThreadState* __tstate = wxPyBeginAllowThreads();
33285 (arg1)->SetThemeEnabled(arg2);
33286 wxPyEndAllowThreads(__tstate);
33287 if (PyErr_Occurred()) SWIG_fail;
33288 }
33289 resultobj = SWIG_Py_Void();
33290 return resultobj;
33291 fail:
33292 return NULL;
33293 }
33294
33295
33296 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33297 PyObject *resultobj = 0;
33298 wxWindow *arg1 = (wxWindow *) 0 ;
33299 bool result;
33300 void *argp1 = 0 ;
33301 int res1 = 0 ;
33302 PyObject *swig_obj[1] ;
33303
33304 if (!args) SWIG_fail;
33305 swig_obj[0] = args;
33306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33307 if (!SWIG_IsOK(res1)) {
33308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33309 }
33310 arg1 = reinterpret_cast< wxWindow * >(argp1);
33311 {
33312 PyThreadState* __tstate = wxPyBeginAllowThreads();
33313 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33314 wxPyEndAllowThreads(__tstate);
33315 if (PyErr_Occurred()) SWIG_fail;
33316 }
33317 {
33318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33319 }
33320 return resultobj;
33321 fail:
33322 return NULL;
33323 }
33324
33325
33326 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33327 PyObject *resultobj = 0;
33328 wxWindow *arg1 = (wxWindow *) 0 ;
33329 void *argp1 = 0 ;
33330 int res1 = 0 ;
33331 PyObject *swig_obj[1] ;
33332
33333 if (!args) SWIG_fail;
33334 swig_obj[0] = args;
33335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33336 if (!SWIG_IsOK(res1)) {
33337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33338 }
33339 arg1 = reinterpret_cast< wxWindow * >(argp1);
33340 {
33341 PyThreadState* __tstate = wxPyBeginAllowThreads();
33342 (arg1)->SetFocus();
33343 wxPyEndAllowThreads(__tstate);
33344 if (PyErr_Occurred()) SWIG_fail;
33345 }
33346 resultobj = SWIG_Py_Void();
33347 return resultobj;
33348 fail:
33349 return NULL;
33350 }
33351
33352
33353 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33354 PyObject *resultobj = 0;
33355 wxWindow *arg1 = (wxWindow *) 0 ;
33356 void *argp1 = 0 ;
33357 int res1 = 0 ;
33358 PyObject *swig_obj[1] ;
33359
33360 if (!args) SWIG_fail;
33361 swig_obj[0] = args;
33362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33363 if (!SWIG_IsOK(res1)) {
33364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33365 }
33366 arg1 = reinterpret_cast< wxWindow * >(argp1);
33367 {
33368 PyThreadState* __tstate = wxPyBeginAllowThreads();
33369 (arg1)->SetFocusFromKbd();
33370 wxPyEndAllowThreads(__tstate);
33371 if (PyErr_Occurred()) SWIG_fail;
33372 }
33373 resultobj = SWIG_Py_Void();
33374 return resultobj;
33375 fail:
33376 return NULL;
33377 }
33378
33379
33380 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33381 PyObject *resultobj = 0;
33382 wxWindow *result = 0 ;
33383
33384 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33385 {
33386 if (!wxPyCheckForApp()) SWIG_fail;
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 result = (wxWindow *)wxWindow::FindFocus();
33389 wxPyEndAllowThreads(__tstate);
33390 if (PyErr_Occurred()) SWIG_fail;
33391 }
33392 {
33393 resultobj = wxPyMake_wxObject(result, 0);
33394 }
33395 return resultobj;
33396 fail:
33397 return NULL;
33398 }
33399
33400
33401 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33402 PyObject *resultobj = 0;
33403 wxWindow *arg1 = (wxWindow *) 0 ;
33404 bool result;
33405 void *argp1 = 0 ;
33406 int res1 = 0 ;
33407 PyObject *swig_obj[1] ;
33408
33409 if (!args) SWIG_fail;
33410 swig_obj[0] = args;
33411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33412 if (!SWIG_IsOK(res1)) {
33413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33414 }
33415 arg1 = reinterpret_cast< wxWindow * >(argp1);
33416 {
33417 PyThreadState* __tstate = wxPyBeginAllowThreads();
33418 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33419 wxPyEndAllowThreads(__tstate);
33420 if (PyErr_Occurred()) SWIG_fail;
33421 }
33422 {
33423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33424 }
33425 return resultobj;
33426 fail:
33427 return NULL;
33428 }
33429
33430
33431 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33432 PyObject *resultobj = 0;
33433 wxWindow *arg1 = (wxWindow *) 0 ;
33434 bool result;
33435 void *argp1 = 0 ;
33436 int res1 = 0 ;
33437 PyObject *swig_obj[1] ;
33438
33439 if (!args) SWIG_fail;
33440 swig_obj[0] = args;
33441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33442 if (!SWIG_IsOK(res1)) {
33443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33444 }
33445 arg1 = reinterpret_cast< wxWindow * >(argp1);
33446 {
33447 PyThreadState* __tstate = wxPyBeginAllowThreads();
33448 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33449 wxPyEndAllowThreads(__tstate);
33450 if (PyErr_Occurred()) SWIG_fail;
33451 }
33452 {
33453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33454 }
33455 return resultobj;
33456 fail:
33457 return NULL;
33458 }
33459
33460
33461 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33462 PyObject *resultobj = 0;
33463 wxWindow *arg1 = (wxWindow *) 0 ;
33464 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33465 bool result;
33466 void *argp1 = 0 ;
33467 int res1 = 0 ;
33468 int val2 ;
33469 int ecode2 = 0 ;
33470 PyObject * obj0 = 0 ;
33471 PyObject * obj1 = 0 ;
33472 char * kwnames[] = {
33473 (char *) "self",(char *) "flags", NULL
33474 };
33475
33476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33478 if (!SWIG_IsOK(res1)) {
33479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33480 }
33481 arg1 = reinterpret_cast< wxWindow * >(argp1);
33482 if (obj1) {
33483 ecode2 = SWIG_AsVal_int(obj1, &val2);
33484 if (!SWIG_IsOK(ecode2)) {
33485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33486 }
33487 arg2 = static_cast< int >(val2);
33488 }
33489 {
33490 PyThreadState* __tstate = wxPyBeginAllowThreads();
33491 result = (bool)(arg1)->Navigate(arg2);
33492 wxPyEndAllowThreads(__tstate);
33493 if (PyErr_Occurred()) SWIG_fail;
33494 }
33495 {
33496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33497 }
33498 return resultobj;
33499 fail:
33500 return NULL;
33501 }
33502
33503
33504 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33505 PyObject *resultobj = 0;
33506 wxWindow *arg1 = (wxWindow *) 0 ;
33507 wxWindow *arg2 = (wxWindow *) 0 ;
33508 void *argp1 = 0 ;
33509 int res1 = 0 ;
33510 void *argp2 = 0 ;
33511 int res2 = 0 ;
33512 PyObject * obj0 = 0 ;
33513 PyObject * obj1 = 0 ;
33514 char * kwnames[] = {
33515 (char *) "self",(char *) "win", NULL
33516 };
33517
33518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33520 if (!SWIG_IsOK(res1)) {
33521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33522 }
33523 arg1 = reinterpret_cast< wxWindow * >(argp1);
33524 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33525 if (!SWIG_IsOK(res2)) {
33526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33527 }
33528 arg2 = reinterpret_cast< wxWindow * >(argp2);
33529 {
33530 PyThreadState* __tstate = wxPyBeginAllowThreads();
33531 (arg1)->MoveAfterInTabOrder(arg2);
33532 wxPyEndAllowThreads(__tstate);
33533 if (PyErr_Occurred()) SWIG_fail;
33534 }
33535 resultobj = SWIG_Py_Void();
33536 return resultobj;
33537 fail:
33538 return NULL;
33539 }
33540
33541
33542 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33543 PyObject *resultobj = 0;
33544 wxWindow *arg1 = (wxWindow *) 0 ;
33545 wxWindow *arg2 = (wxWindow *) 0 ;
33546 void *argp1 = 0 ;
33547 int res1 = 0 ;
33548 void *argp2 = 0 ;
33549 int res2 = 0 ;
33550 PyObject * obj0 = 0 ;
33551 PyObject * obj1 = 0 ;
33552 char * kwnames[] = {
33553 (char *) "self",(char *) "win", NULL
33554 };
33555
33556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33558 if (!SWIG_IsOK(res1)) {
33559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33560 }
33561 arg1 = reinterpret_cast< wxWindow * >(argp1);
33562 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33563 if (!SWIG_IsOK(res2)) {
33564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33565 }
33566 arg2 = reinterpret_cast< wxWindow * >(argp2);
33567 {
33568 PyThreadState* __tstate = wxPyBeginAllowThreads();
33569 (arg1)->MoveBeforeInTabOrder(arg2);
33570 wxPyEndAllowThreads(__tstate);
33571 if (PyErr_Occurred()) SWIG_fail;
33572 }
33573 resultobj = SWIG_Py_Void();
33574 return resultobj;
33575 fail:
33576 return NULL;
33577 }
33578
33579
33580 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33581 PyObject *resultobj = 0;
33582 wxWindow *arg1 = (wxWindow *) 0 ;
33583 PyObject *result = 0 ;
33584 void *argp1 = 0 ;
33585 int res1 = 0 ;
33586 PyObject *swig_obj[1] ;
33587
33588 if (!args) SWIG_fail;
33589 swig_obj[0] = args;
33590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33591 if (!SWIG_IsOK(res1)) {
33592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33593 }
33594 arg1 = reinterpret_cast< wxWindow * >(argp1);
33595 {
33596 PyThreadState* __tstate = wxPyBeginAllowThreads();
33597 result = (PyObject *)wxWindow_GetChildren(arg1);
33598 wxPyEndAllowThreads(__tstate);
33599 if (PyErr_Occurred()) SWIG_fail;
33600 }
33601 resultobj = result;
33602 return resultobj;
33603 fail:
33604 return NULL;
33605 }
33606
33607
33608 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33609 PyObject *resultobj = 0;
33610 wxWindow *arg1 = (wxWindow *) 0 ;
33611 wxWindow *result = 0 ;
33612 void *argp1 = 0 ;
33613 int res1 = 0 ;
33614 PyObject *swig_obj[1] ;
33615
33616 if (!args) SWIG_fail;
33617 swig_obj[0] = args;
33618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33619 if (!SWIG_IsOK(res1)) {
33620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33621 }
33622 arg1 = reinterpret_cast< wxWindow * >(argp1);
33623 {
33624 PyThreadState* __tstate = wxPyBeginAllowThreads();
33625 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33626 wxPyEndAllowThreads(__tstate);
33627 if (PyErr_Occurred()) SWIG_fail;
33628 }
33629 {
33630 resultobj = wxPyMake_wxObject(result, 0);
33631 }
33632 return resultobj;
33633 fail:
33634 return NULL;
33635 }
33636
33637
33638 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33639 PyObject *resultobj = 0;
33640 wxWindow *arg1 = (wxWindow *) 0 ;
33641 wxWindow *result = 0 ;
33642 void *argp1 = 0 ;
33643 int res1 = 0 ;
33644 PyObject *swig_obj[1] ;
33645
33646 if (!args) SWIG_fail;
33647 swig_obj[0] = args;
33648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33649 if (!SWIG_IsOK(res1)) {
33650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33651 }
33652 arg1 = reinterpret_cast< wxWindow * >(argp1);
33653 {
33654 PyThreadState* __tstate = wxPyBeginAllowThreads();
33655 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33656 wxPyEndAllowThreads(__tstate);
33657 if (PyErr_Occurred()) SWIG_fail;
33658 }
33659 {
33660 resultobj = wxPyMake_wxObject(result, 0);
33661 }
33662 return resultobj;
33663 fail:
33664 return NULL;
33665 }
33666
33667
33668 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33669 PyObject *resultobj = 0;
33670 wxWindow *arg1 = (wxWindow *) 0 ;
33671 bool result;
33672 void *argp1 = 0 ;
33673 int res1 = 0 ;
33674 PyObject *swig_obj[1] ;
33675
33676 if (!args) SWIG_fail;
33677 swig_obj[0] = args;
33678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33679 if (!SWIG_IsOK(res1)) {
33680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33681 }
33682 arg1 = reinterpret_cast< wxWindow * >(argp1);
33683 {
33684 PyThreadState* __tstate = wxPyBeginAllowThreads();
33685 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
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_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33699 PyObject *resultobj = 0;
33700 wxWindow *arg1 = (wxWindow *) 0 ;
33701 wxWindow *arg2 = (wxWindow *) 0 ;
33702 bool result;
33703 void *argp1 = 0 ;
33704 int res1 = 0 ;
33705 void *argp2 = 0 ;
33706 int res2 = 0 ;
33707 PyObject * obj0 = 0 ;
33708 PyObject * obj1 = 0 ;
33709 char * kwnames[] = {
33710 (char *) "self",(char *) "newParent", NULL
33711 };
33712
33713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33715 if (!SWIG_IsOK(res1)) {
33716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33717 }
33718 arg1 = reinterpret_cast< wxWindow * >(argp1);
33719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33720 if (!SWIG_IsOK(res2)) {
33721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33722 }
33723 arg2 = reinterpret_cast< wxWindow * >(argp2);
33724 {
33725 PyThreadState* __tstate = wxPyBeginAllowThreads();
33726 result = (bool)(arg1)->Reparent(arg2);
33727 wxPyEndAllowThreads(__tstate);
33728 if (PyErr_Occurred()) SWIG_fail;
33729 }
33730 {
33731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33732 }
33733 return resultobj;
33734 fail:
33735 return NULL;
33736 }
33737
33738
33739 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33740 PyObject *resultobj = 0;
33741 wxWindow *arg1 = (wxWindow *) 0 ;
33742 wxWindow *arg2 = (wxWindow *) 0 ;
33743 void *argp1 = 0 ;
33744 int res1 = 0 ;
33745 void *argp2 = 0 ;
33746 int res2 = 0 ;
33747 PyObject * obj0 = 0 ;
33748 PyObject * obj1 = 0 ;
33749 char * kwnames[] = {
33750 (char *) "self",(char *) "child", NULL
33751 };
33752
33753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33755 if (!SWIG_IsOK(res1)) {
33756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33757 }
33758 arg1 = reinterpret_cast< wxWindow * >(argp1);
33759 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33760 if (!SWIG_IsOK(res2)) {
33761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33762 }
33763 arg2 = reinterpret_cast< wxWindow * >(argp2);
33764 {
33765 PyThreadState* __tstate = wxPyBeginAllowThreads();
33766 (arg1)->AddChild(arg2);
33767 wxPyEndAllowThreads(__tstate);
33768 if (PyErr_Occurred()) SWIG_fail;
33769 }
33770 resultobj = SWIG_Py_Void();
33771 return resultobj;
33772 fail:
33773 return NULL;
33774 }
33775
33776
33777 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33778 PyObject *resultobj = 0;
33779 wxWindow *arg1 = (wxWindow *) 0 ;
33780 wxWindow *arg2 = (wxWindow *) 0 ;
33781 void *argp1 = 0 ;
33782 int res1 = 0 ;
33783 void *argp2 = 0 ;
33784 int res2 = 0 ;
33785 PyObject * obj0 = 0 ;
33786 PyObject * obj1 = 0 ;
33787 char * kwnames[] = {
33788 (char *) "self",(char *) "child", NULL
33789 };
33790
33791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33793 if (!SWIG_IsOK(res1)) {
33794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33795 }
33796 arg1 = reinterpret_cast< wxWindow * >(argp1);
33797 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33798 if (!SWIG_IsOK(res2)) {
33799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33800 }
33801 arg2 = reinterpret_cast< wxWindow * >(argp2);
33802 {
33803 PyThreadState* __tstate = wxPyBeginAllowThreads();
33804 (arg1)->RemoveChild(arg2);
33805 wxPyEndAllowThreads(__tstate);
33806 if (PyErr_Occurred()) SWIG_fail;
33807 }
33808 resultobj = SWIG_Py_Void();
33809 return resultobj;
33810 fail:
33811 return NULL;
33812 }
33813
33814
33815 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33816 PyObject *resultobj = 0;
33817 wxWindow *arg1 = (wxWindow *) 0 ;
33818 bool arg2 ;
33819 void *argp1 = 0 ;
33820 int res1 = 0 ;
33821 bool val2 ;
33822 int ecode2 = 0 ;
33823 PyObject * obj0 = 0 ;
33824 PyObject * obj1 = 0 ;
33825 char * kwnames[] = {
33826 (char *) "self",(char *) "on", NULL
33827 };
33828
33829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33831 if (!SWIG_IsOK(res1)) {
33832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33833 }
33834 arg1 = reinterpret_cast< wxWindow * >(argp1);
33835 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33836 if (!SWIG_IsOK(ecode2)) {
33837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33838 }
33839 arg2 = static_cast< bool >(val2);
33840 {
33841 PyThreadState* __tstate = wxPyBeginAllowThreads();
33842 wxWindow_SetDoubleBuffered(arg1,arg2);
33843 wxPyEndAllowThreads(__tstate);
33844 if (PyErr_Occurred()) SWIG_fail;
33845 }
33846 resultobj = SWIG_Py_Void();
33847 return resultobj;
33848 fail:
33849 return NULL;
33850 }
33851
33852
33853 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33854 PyObject *resultobj = 0;
33855 wxWindow *arg1 = (wxWindow *) 0 ;
33856 long arg2 ;
33857 wxWindow *result = 0 ;
33858 void *argp1 = 0 ;
33859 int res1 = 0 ;
33860 long val2 ;
33861 int ecode2 = 0 ;
33862 PyObject * obj0 = 0 ;
33863 PyObject * obj1 = 0 ;
33864 char * kwnames[] = {
33865 (char *) "self",(char *) "winid", NULL
33866 };
33867
33868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33870 if (!SWIG_IsOK(res1)) {
33871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33872 }
33873 arg1 = reinterpret_cast< wxWindow * >(argp1);
33874 ecode2 = SWIG_AsVal_long(obj1, &val2);
33875 if (!SWIG_IsOK(ecode2)) {
33876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33877 }
33878 arg2 = static_cast< long >(val2);
33879 {
33880 PyThreadState* __tstate = wxPyBeginAllowThreads();
33881 result = (wxWindow *)(arg1)->FindWindow(arg2);
33882 wxPyEndAllowThreads(__tstate);
33883 if (PyErr_Occurred()) SWIG_fail;
33884 }
33885 {
33886 resultobj = wxPyMake_wxObject(result, 0);
33887 }
33888 return resultobj;
33889 fail:
33890 return NULL;
33891 }
33892
33893
33894 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33895 PyObject *resultobj = 0;
33896 wxWindow *arg1 = (wxWindow *) 0 ;
33897 wxString *arg2 = 0 ;
33898 wxWindow *result = 0 ;
33899 void *argp1 = 0 ;
33900 int res1 = 0 ;
33901 bool temp2 = false ;
33902 PyObject * obj0 = 0 ;
33903 PyObject * obj1 = 0 ;
33904 char * kwnames[] = {
33905 (char *) "self",(char *) "name", NULL
33906 };
33907
33908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33910 if (!SWIG_IsOK(res1)) {
33911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33912 }
33913 arg1 = reinterpret_cast< wxWindow * >(argp1);
33914 {
33915 arg2 = wxString_in_helper(obj1);
33916 if (arg2 == NULL) SWIG_fail;
33917 temp2 = true;
33918 }
33919 {
33920 PyThreadState* __tstate = wxPyBeginAllowThreads();
33921 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33922 wxPyEndAllowThreads(__tstate);
33923 if (PyErr_Occurred()) SWIG_fail;
33924 }
33925 {
33926 resultobj = wxPyMake_wxObject(result, 0);
33927 }
33928 {
33929 if (temp2)
33930 delete arg2;
33931 }
33932 return resultobj;
33933 fail:
33934 {
33935 if (temp2)
33936 delete arg2;
33937 }
33938 return NULL;
33939 }
33940
33941
33942 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33943 PyObject *resultobj = 0;
33944 wxWindow *arg1 = (wxWindow *) 0 ;
33945 wxEvtHandler *result = 0 ;
33946 void *argp1 = 0 ;
33947 int res1 = 0 ;
33948 PyObject *swig_obj[1] ;
33949
33950 if (!args) SWIG_fail;
33951 swig_obj[0] = args;
33952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33953 if (!SWIG_IsOK(res1)) {
33954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33955 }
33956 arg1 = reinterpret_cast< wxWindow * >(argp1);
33957 {
33958 PyThreadState* __tstate = wxPyBeginAllowThreads();
33959 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33960 wxPyEndAllowThreads(__tstate);
33961 if (PyErr_Occurred()) SWIG_fail;
33962 }
33963 {
33964 resultobj = wxPyMake_wxObject(result, 0);
33965 }
33966 return resultobj;
33967 fail:
33968 return NULL;
33969 }
33970
33971
33972 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33973 PyObject *resultobj = 0;
33974 wxWindow *arg1 = (wxWindow *) 0 ;
33975 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33976 void *argp1 = 0 ;
33977 int res1 = 0 ;
33978 void *argp2 = 0 ;
33979 int res2 = 0 ;
33980 PyObject * obj0 = 0 ;
33981 PyObject * obj1 = 0 ;
33982 char * kwnames[] = {
33983 (char *) "self",(char *) "handler", NULL
33984 };
33985
33986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33988 if (!SWIG_IsOK(res1)) {
33989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33990 }
33991 arg1 = reinterpret_cast< wxWindow * >(argp1);
33992 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33993 if (!SWIG_IsOK(res2)) {
33994 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33995 }
33996 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33997 {
33998 PyThreadState* __tstate = wxPyBeginAllowThreads();
33999 (arg1)->SetEventHandler(arg2);
34000 wxPyEndAllowThreads(__tstate);
34001 if (PyErr_Occurred()) SWIG_fail;
34002 }
34003 resultobj = SWIG_Py_Void();
34004 return resultobj;
34005 fail:
34006 return NULL;
34007 }
34008
34009
34010 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34011 PyObject *resultobj = 0;
34012 wxWindow *arg1 = (wxWindow *) 0 ;
34013 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34014 void *argp1 = 0 ;
34015 int res1 = 0 ;
34016 void *argp2 = 0 ;
34017 int res2 = 0 ;
34018 PyObject * obj0 = 0 ;
34019 PyObject * obj1 = 0 ;
34020 char * kwnames[] = {
34021 (char *) "self",(char *) "handler", NULL
34022 };
34023
34024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34026 if (!SWIG_IsOK(res1)) {
34027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34028 }
34029 arg1 = reinterpret_cast< wxWindow * >(argp1);
34030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34031 if (!SWIG_IsOK(res2)) {
34032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34033 }
34034 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34035 {
34036 PyThreadState* __tstate = wxPyBeginAllowThreads();
34037 (arg1)->PushEventHandler(arg2);
34038 wxPyEndAllowThreads(__tstate);
34039 if (PyErr_Occurred()) SWIG_fail;
34040 }
34041 resultobj = SWIG_Py_Void();
34042 return resultobj;
34043 fail:
34044 return NULL;
34045 }
34046
34047
34048 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34049 PyObject *resultobj = 0;
34050 wxWindow *arg1 = (wxWindow *) 0 ;
34051 bool arg2 = (bool) false ;
34052 wxEvtHandler *result = 0 ;
34053 void *argp1 = 0 ;
34054 int res1 = 0 ;
34055 bool val2 ;
34056 int ecode2 = 0 ;
34057 PyObject * obj0 = 0 ;
34058 PyObject * obj1 = 0 ;
34059 char * kwnames[] = {
34060 (char *) "self",(char *) "deleteHandler", NULL
34061 };
34062
34063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34065 if (!SWIG_IsOK(res1)) {
34066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34067 }
34068 arg1 = reinterpret_cast< wxWindow * >(argp1);
34069 if (obj1) {
34070 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34071 if (!SWIG_IsOK(ecode2)) {
34072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34073 }
34074 arg2 = static_cast< bool >(val2);
34075 }
34076 {
34077 PyThreadState* __tstate = wxPyBeginAllowThreads();
34078 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34079 wxPyEndAllowThreads(__tstate);
34080 if (PyErr_Occurred()) SWIG_fail;
34081 }
34082 {
34083 resultobj = wxPyMake_wxObject(result, 0);
34084 }
34085 return resultobj;
34086 fail:
34087 return NULL;
34088 }
34089
34090
34091 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34092 PyObject *resultobj = 0;
34093 wxWindow *arg1 = (wxWindow *) 0 ;
34094 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34095 bool result;
34096 void *argp1 = 0 ;
34097 int res1 = 0 ;
34098 void *argp2 = 0 ;
34099 int res2 = 0 ;
34100 PyObject * obj0 = 0 ;
34101 PyObject * obj1 = 0 ;
34102 char * kwnames[] = {
34103 (char *) "self",(char *) "handler", NULL
34104 };
34105
34106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34108 if (!SWIG_IsOK(res1)) {
34109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34110 }
34111 arg1 = reinterpret_cast< wxWindow * >(argp1);
34112 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34113 if (!SWIG_IsOK(res2)) {
34114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34115 }
34116 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34117 {
34118 PyThreadState* __tstate = wxPyBeginAllowThreads();
34119 result = (bool)(arg1)->RemoveEventHandler(arg2);
34120 wxPyEndAllowThreads(__tstate);
34121 if (PyErr_Occurred()) SWIG_fail;
34122 }
34123 {
34124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34125 }
34126 return resultobj;
34127 fail:
34128 return NULL;
34129 }
34130
34131
34132 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34133 PyObject *resultobj = 0;
34134 wxWindow *arg1 = (wxWindow *) 0 ;
34135 wxValidator *arg2 = 0 ;
34136 void *argp1 = 0 ;
34137 int res1 = 0 ;
34138 void *argp2 = 0 ;
34139 int res2 = 0 ;
34140 PyObject * obj0 = 0 ;
34141 PyObject * obj1 = 0 ;
34142 char * kwnames[] = {
34143 (char *) "self",(char *) "validator", NULL
34144 };
34145
34146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34148 if (!SWIG_IsOK(res1)) {
34149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34150 }
34151 arg1 = reinterpret_cast< wxWindow * >(argp1);
34152 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34153 if (!SWIG_IsOK(res2)) {
34154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34155 }
34156 if (!argp2) {
34157 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34158 }
34159 arg2 = reinterpret_cast< wxValidator * >(argp2);
34160 {
34161 PyThreadState* __tstate = wxPyBeginAllowThreads();
34162 (arg1)->SetValidator((wxValidator const &)*arg2);
34163 wxPyEndAllowThreads(__tstate);
34164 if (PyErr_Occurred()) SWIG_fail;
34165 }
34166 resultobj = SWIG_Py_Void();
34167 return resultobj;
34168 fail:
34169 return NULL;
34170 }
34171
34172
34173 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34174 PyObject *resultobj = 0;
34175 wxWindow *arg1 = (wxWindow *) 0 ;
34176 wxValidator *result = 0 ;
34177 void *argp1 = 0 ;
34178 int res1 = 0 ;
34179 PyObject *swig_obj[1] ;
34180
34181 if (!args) SWIG_fail;
34182 swig_obj[0] = args;
34183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34184 if (!SWIG_IsOK(res1)) {
34185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34186 }
34187 arg1 = reinterpret_cast< wxWindow * >(argp1);
34188 {
34189 PyThreadState* __tstate = wxPyBeginAllowThreads();
34190 result = (wxValidator *)(arg1)->GetValidator();
34191 wxPyEndAllowThreads(__tstate);
34192 if (PyErr_Occurred()) SWIG_fail;
34193 }
34194 {
34195 resultobj = wxPyMake_wxObject(result, (bool)0);
34196 }
34197 return resultobj;
34198 fail:
34199 return NULL;
34200 }
34201
34202
34203 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34204 PyObject *resultobj = 0;
34205 wxWindow *arg1 = (wxWindow *) 0 ;
34206 bool result;
34207 void *argp1 = 0 ;
34208 int res1 = 0 ;
34209 PyObject *swig_obj[1] ;
34210
34211 if (!args) SWIG_fail;
34212 swig_obj[0] = args;
34213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34214 if (!SWIG_IsOK(res1)) {
34215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34216 }
34217 arg1 = reinterpret_cast< wxWindow * >(argp1);
34218 {
34219 PyThreadState* __tstate = wxPyBeginAllowThreads();
34220 result = (bool)(arg1)->Validate();
34221 wxPyEndAllowThreads(__tstate);
34222 if (PyErr_Occurred()) SWIG_fail;
34223 }
34224 {
34225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34226 }
34227 return resultobj;
34228 fail:
34229 return NULL;
34230 }
34231
34232
34233 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34234 PyObject *resultobj = 0;
34235 wxWindow *arg1 = (wxWindow *) 0 ;
34236 bool result;
34237 void *argp1 = 0 ;
34238 int res1 = 0 ;
34239 PyObject *swig_obj[1] ;
34240
34241 if (!args) SWIG_fail;
34242 swig_obj[0] = args;
34243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34244 if (!SWIG_IsOK(res1)) {
34245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34246 }
34247 arg1 = reinterpret_cast< wxWindow * >(argp1);
34248 {
34249 PyThreadState* __tstate = wxPyBeginAllowThreads();
34250 result = (bool)(arg1)->TransferDataToWindow();
34251 wxPyEndAllowThreads(__tstate);
34252 if (PyErr_Occurred()) SWIG_fail;
34253 }
34254 {
34255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34256 }
34257 return resultobj;
34258 fail:
34259 return NULL;
34260 }
34261
34262
34263 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34264 PyObject *resultobj = 0;
34265 wxWindow *arg1 = (wxWindow *) 0 ;
34266 bool result;
34267 void *argp1 = 0 ;
34268 int res1 = 0 ;
34269 PyObject *swig_obj[1] ;
34270
34271 if (!args) SWIG_fail;
34272 swig_obj[0] = args;
34273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34274 if (!SWIG_IsOK(res1)) {
34275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34276 }
34277 arg1 = reinterpret_cast< wxWindow * >(argp1);
34278 {
34279 PyThreadState* __tstate = wxPyBeginAllowThreads();
34280 result = (bool)(arg1)->TransferDataFromWindow();
34281 wxPyEndAllowThreads(__tstate);
34282 if (PyErr_Occurred()) SWIG_fail;
34283 }
34284 {
34285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34286 }
34287 return resultobj;
34288 fail:
34289 return NULL;
34290 }
34291
34292
34293 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34294 PyObject *resultobj = 0;
34295 wxWindow *arg1 = (wxWindow *) 0 ;
34296 void *argp1 = 0 ;
34297 int res1 = 0 ;
34298 PyObject *swig_obj[1] ;
34299
34300 if (!args) SWIG_fail;
34301 swig_obj[0] = args;
34302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34303 if (!SWIG_IsOK(res1)) {
34304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34305 }
34306 arg1 = reinterpret_cast< wxWindow * >(argp1);
34307 {
34308 PyThreadState* __tstate = wxPyBeginAllowThreads();
34309 (arg1)->InitDialog();
34310 wxPyEndAllowThreads(__tstate);
34311 if (PyErr_Occurred()) SWIG_fail;
34312 }
34313 resultobj = SWIG_Py_Void();
34314 return resultobj;
34315 fail:
34316 return NULL;
34317 }
34318
34319
34320 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34321 PyObject *resultobj = 0;
34322 wxWindow *arg1 = (wxWindow *) 0 ;
34323 wxAcceleratorTable *arg2 = 0 ;
34324 void *argp1 = 0 ;
34325 int res1 = 0 ;
34326 void *argp2 = 0 ;
34327 int res2 = 0 ;
34328 PyObject * obj0 = 0 ;
34329 PyObject * obj1 = 0 ;
34330 char * kwnames[] = {
34331 (char *) "self",(char *) "accel", NULL
34332 };
34333
34334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34336 if (!SWIG_IsOK(res1)) {
34337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34338 }
34339 arg1 = reinterpret_cast< wxWindow * >(argp1);
34340 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34341 if (!SWIG_IsOK(res2)) {
34342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34343 }
34344 if (!argp2) {
34345 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34346 }
34347 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34348 {
34349 PyThreadState* __tstate = wxPyBeginAllowThreads();
34350 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34351 wxPyEndAllowThreads(__tstate);
34352 if (PyErr_Occurred()) SWIG_fail;
34353 }
34354 resultobj = SWIG_Py_Void();
34355 return resultobj;
34356 fail:
34357 return NULL;
34358 }
34359
34360
34361 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34362 PyObject *resultobj = 0;
34363 wxWindow *arg1 = (wxWindow *) 0 ;
34364 wxAcceleratorTable *result = 0 ;
34365 void *argp1 = 0 ;
34366 int res1 = 0 ;
34367 PyObject *swig_obj[1] ;
34368
34369 if (!args) SWIG_fail;
34370 swig_obj[0] = args;
34371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34372 if (!SWIG_IsOK(res1)) {
34373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34374 }
34375 arg1 = reinterpret_cast< wxWindow * >(argp1);
34376 {
34377 PyThreadState* __tstate = wxPyBeginAllowThreads();
34378 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34379 wxPyEndAllowThreads(__tstate);
34380 if (PyErr_Occurred()) SWIG_fail;
34381 }
34382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34383 return resultobj;
34384 fail:
34385 return NULL;
34386 }
34387
34388
34389 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34390 PyObject *resultobj = 0;
34391 wxWindow *arg1 = (wxWindow *) 0 ;
34392 int arg2 ;
34393 int arg3 ;
34394 int arg4 ;
34395 bool result;
34396 void *argp1 = 0 ;
34397 int res1 = 0 ;
34398 int val2 ;
34399 int ecode2 = 0 ;
34400 int val3 ;
34401 int ecode3 = 0 ;
34402 int val4 ;
34403 int ecode4 = 0 ;
34404 PyObject * obj0 = 0 ;
34405 PyObject * obj1 = 0 ;
34406 PyObject * obj2 = 0 ;
34407 PyObject * obj3 = 0 ;
34408 char * kwnames[] = {
34409 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34410 };
34411
34412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34414 if (!SWIG_IsOK(res1)) {
34415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34416 }
34417 arg1 = reinterpret_cast< wxWindow * >(argp1);
34418 ecode2 = SWIG_AsVal_int(obj1, &val2);
34419 if (!SWIG_IsOK(ecode2)) {
34420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34421 }
34422 arg2 = static_cast< int >(val2);
34423 ecode3 = SWIG_AsVal_int(obj2, &val3);
34424 if (!SWIG_IsOK(ecode3)) {
34425 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34426 }
34427 arg3 = static_cast< int >(val3);
34428 ecode4 = SWIG_AsVal_int(obj3, &val4);
34429 if (!SWIG_IsOK(ecode4)) {
34430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34431 }
34432 arg4 = static_cast< int >(val4);
34433 {
34434 PyThreadState* __tstate = wxPyBeginAllowThreads();
34435 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34436 wxPyEndAllowThreads(__tstate);
34437 if (PyErr_Occurred()) SWIG_fail;
34438 }
34439 {
34440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34441 }
34442 return resultobj;
34443 fail:
34444 return NULL;
34445 }
34446
34447
34448 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34449 PyObject *resultobj = 0;
34450 wxWindow *arg1 = (wxWindow *) 0 ;
34451 int arg2 ;
34452 bool result;
34453 void *argp1 = 0 ;
34454 int res1 = 0 ;
34455 int val2 ;
34456 int ecode2 = 0 ;
34457 PyObject * obj0 = 0 ;
34458 PyObject * obj1 = 0 ;
34459 char * kwnames[] = {
34460 (char *) "self",(char *) "hotkeyId", NULL
34461 };
34462
34463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34465 if (!SWIG_IsOK(res1)) {
34466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34467 }
34468 arg1 = reinterpret_cast< wxWindow * >(argp1);
34469 ecode2 = SWIG_AsVal_int(obj1, &val2);
34470 if (!SWIG_IsOK(ecode2)) {
34471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34472 }
34473 arg2 = static_cast< int >(val2);
34474 {
34475 PyThreadState* __tstate = wxPyBeginAllowThreads();
34476 result = (bool)wxWindow_UnregisterHotKey(arg1,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_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34490 PyObject *resultobj = 0;
34491 wxWindow *arg1 = (wxWindow *) 0 ;
34492 wxPoint *arg2 = 0 ;
34493 wxPoint result;
34494 void *argp1 = 0 ;
34495 int res1 = 0 ;
34496 wxPoint temp2 ;
34497 PyObject * obj0 = 0 ;
34498 PyObject * obj1 = 0 ;
34499 char * kwnames[] = {
34500 (char *) "self",(char *) "pt", NULL
34501 };
34502
34503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",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_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34507 }
34508 arg1 = reinterpret_cast< wxWindow * >(argp1);
34509 {
34510 arg2 = &temp2;
34511 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34512 }
34513 {
34514 PyThreadState* __tstate = wxPyBeginAllowThreads();
34515 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34520 return resultobj;
34521 fail:
34522 return NULL;
34523 }
34524
34525
34526 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34527 PyObject *resultobj = 0;
34528 wxWindow *arg1 = (wxWindow *) 0 ;
34529 wxSize *arg2 = 0 ;
34530 wxSize result;
34531 void *argp1 = 0 ;
34532 int res1 = 0 ;
34533 wxSize temp2 ;
34534 PyObject * obj0 = 0 ;
34535 PyObject * obj1 = 0 ;
34536 char * kwnames[] = {
34537 (char *) "self",(char *) "sz", NULL
34538 };
34539
34540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34542 if (!SWIG_IsOK(res1)) {
34543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34544 }
34545 arg1 = reinterpret_cast< wxWindow * >(argp1);
34546 {
34547 arg2 = &temp2;
34548 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34549 }
34550 {
34551 PyThreadState* __tstate = wxPyBeginAllowThreads();
34552 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34553 wxPyEndAllowThreads(__tstate);
34554 if (PyErr_Occurred()) SWIG_fail;
34555 }
34556 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34557 return resultobj;
34558 fail:
34559 return NULL;
34560 }
34561
34562
34563 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34564 PyObject *resultobj = 0;
34565 wxWindow *arg1 = (wxWindow *) 0 ;
34566 wxPoint *arg2 = 0 ;
34567 wxPoint result;
34568 void *argp1 = 0 ;
34569 int res1 = 0 ;
34570 wxPoint temp2 ;
34571 PyObject * obj0 = 0 ;
34572 PyObject * obj1 = 0 ;
34573 char * kwnames[] = {
34574 (char *) "self",(char *) "pt", NULL
34575 };
34576
34577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34579 if (!SWIG_IsOK(res1)) {
34580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34581 }
34582 arg1 = reinterpret_cast< wxWindow * >(argp1);
34583 {
34584 arg2 = &temp2;
34585 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34586 }
34587 {
34588 PyThreadState* __tstate = wxPyBeginAllowThreads();
34589 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34590 wxPyEndAllowThreads(__tstate);
34591 if (PyErr_Occurred()) SWIG_fail;
34592 }
34593 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34594 return resultobj;
34595 fail:
34596 return NULL;
34597 }
34598
34599
34600 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34601 PyObject *resultobj = 0;
34602 wxWindow *arg1 = (wxWindow *) 0 ;
34603 wxSize *arg2 = 0 ;
34604 wxSize result;
34605 void *argp1 = 0 ;
34606 int res1 = 0 ;
34607 wxSize temp2 ;
34608 PyObject * obj0 = 0 ;
34609 PyObject * obj1 = 0 ;
34610 char * kwnames[] = {
34611 (char *) "self",(char *) "sz", NULL
34612 };
34613
34614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34616 if (!SWIG_IsOK(res1)) {
34617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34618 }
34619 arg1 = reinterpret_cast< wxWindow * >(argp1);
34620 {
34621 arg2 = &temp2;
34622 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34623 }
34624 {
34625 PyThreadState* __tstate = wxPyBeginAllowThreads();
34626 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34627 wxPyEndAllowThreads(__tstate);
34628 if (PyErr_Occurred()) SWIG_fail;
34629 }
34630 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34631 return resultobj;
34632 fail:
34633 return NULL;
34634 }
34635
34636
34637 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34638 PyObject *resultobj = 0;
34639 wxWindow *arg1 = (wxWindow *) 0 ;
34640 wxPoint *arg2 = 0 ;
34641 wxPoint result;
34642 void *argp1 = 0 ;
34643 int res1 = 0 ;
34644 wxPoint temp2 ;
34645 PyObject * obj0 = 0 ;
34646 PyObject * obj1 = 0 ;
34647 char * kwnames[] = {
34648 (char *) "self",(char *) "pt", NULL
34649 };
34650
34651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34653 if (!SWIG_IsOK(res1)) {
34654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34655 }
34656 arg1 = reinterpret_cast< wxWindow * >(argp1);
34657 {
34658 arg2 = &temp2;
34659 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34660 }
34661 {
34662 PyThreadState* __tstate = wxPyBeginAllowThreads();
34663 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34664 wxPyEndAllowThreads(__tstate);
34665 if (PyErr_Occurred()) SWIG_fail;
34666 }
34667 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34668 return resultobj;
34669 fail:
34670 return NULL;
34671 }
34672
34673
34674 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34675 PyObject *resultobj = 0;
34676 wxWindow *arg1 = (wxWindow *) 0 ;
34677 wxSize *arg2 = 0 ;
34678 wxSize result;
34679 void *argp1 = 0 ;
34680 int res1 = 0 ;
34681 wxSize temp2 ;
34682 PyObject * obj0 = 0 ;
34683 PyObject * obj1 = 0 ;
34684 char * kwnames[] = {
34685 (char *) "self",(char *) "sz", NULL
34686 };
34687
34688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34690 if (!SWIG_IsOK(res1)) {
34691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34692 }
34693 arg1 = reinterpret_cast< wxWindow * >(argp1);
34694 {
34695 arg2 = &temp2;
34696 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34697 }
34698 {
34699 PyThreadState* __tstate = wxPyBeginAllowThreads();
34700 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34701 wxPyEndAllowThreads(__tstate);
34702 if (PyErr_Occurred()) SWIG_fail;
34703 }
34704 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34705 return resultobj;
34706 fail:
34707 return NULL;
34708 }
34709
34710
34711 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34712 PyObject *resultobj = 0;
34713 wxWindow *arg1 = (wxWindow *) 0 ;
34714 int arg2 ;
34715 int arg3 ;
34716 void *argp1 = 0 ;
34717 int res1 = 0 ;
34718 int val2 ;
34719 int ecode2 = 0 ;
34720 int val3 ;
34721 int ecode3 = 0 ;
34722 PyObject * obj0 = 0 ;
34723 PyObject * obj1 = 0 ;
34724 PyObject * obj2 = 0 ;
34725 char * kwnames[] = {
34726 (char *) "self",(char *) "x",(char *) "y", NULL
34727 };
34728
34729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34731 if (!SWIG_IsOK(res1)) {
34732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34733 }
34734 arg1 = reinterpret_cast< wxWindow * >(argp1);
34735 ecode2 = SWIG_AsVal_int(obj1, &val2);
34736 if (!SWIG_IsOK(ecode2)) {
34737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34738 }
34739 arg2 = static_cast< int >(val2);
34740 ecode3 = SWIG_AsVal_int(obj2, &val3);
34741 if (!SWIG_IsOK(ecode3)) {
34742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34743 }
34744 arg3 = static_cast< int >(val3);
34745 {
34746 PyThreadState* __tstate = wxPyBeginAllowThreads();
34747 (arg1)->WarpPointer(arg2,arg3);
34748 wxPyEndAllowThreads(__tstate);
34749 if (PyErr_Occurred()) SWIG_fail;
34750 }
34751 resultobj = SWIG_Py_Void();
34752 return resultobj;
34753 fail:
34754 return NULL;
34755 }
34756
34757
34758 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34759 PyObject *resultobj = 0;
34760 wxWindow *arg1 = (wxWindow *) 0 ;
34761 void *argp1 = 0 ;
34762 int res1 = 0 ;
34763 PyObject *swig_obj[1] ;
34764
34765 if (!args) SWIG_fail;
34766 swig_obj[0] = args;
34767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34768 if (!SWIG_IsOK(res1)) {
34769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34770 }
34771 arg1 = reinterpret_cast< wxWindow * >(argp1);
34772 {
34773 PyThreadState* __tstate = wxPyBeginAllowThreads();
34774 (arg1)->CaptureMouse();
34775 wxPyEndAllowThreads(__tstate);
34776 if (PyErr_Occurred()) SWIG_fail;
34777 }
34778 resultobj = SWIG_Py_Void();
34779 return resultobj;
34780 fail:
34781 return NULL;
34782 }
34783
34784
34785 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34786 PyObject *resultobj = 0;
34787 wxWindow *arg1 = (wxWindow *) 0 ;
34788 void *argp1 = 0 ;
34789 int res1 = 0 ;
34790 PyObject *swig_obj[1] ;
34791
34792 if (!args) SWIG_fail;
34793 swig_obj[0] = args;
34794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34795 if (!SWIG_IsOK(res1)) {
34796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34797 }
34798 arg1 = reinterpret_cast< wxWindow * >(argp1);
34799 {
34800 PyThreadState* __tstate = wxPyBeginAllowThreads();
34801 (arg1)->ReleaseMouse();
34802 wxPyEndAllowThreads(__tstate);
34803 if (PyErr_Occurred()) SWIG_fail;
34804 }
34805 resultobj = SWIG_Py_Void();
34806 return resultobj;
34807 fail:
34808 return NULL;
34809 }
34810
34811
34812 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34813 PyObject *resultobj = 0;
34814 wxWindow *result = 0 ;
34815
34816 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34817 {
34818 if (!wxPyCheckForApp()) SWIG_fail;
34819 PyThreadState* __tstate = wxPyBeginAllowThreads();
34820 result = (wxWindow *)wxWindow::GetCapture();
34821 wxPyEndAllowThreads(__tstate);
34822 if (PyErr_Occurred()) SWIG_fail;
34823 }
34824 {
34825 resultobj = wxPyMake_wxObject(result, 0);
34826 }
34827 return resultobj;
34828 fail:
34829 return NULL;
34830 }
34831
34832
34833 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34834 PyObject *resultobj = 0;
34835 wxWindow *arg1 = (wxWindow *) 0 ;
34836 bool result;
34837 void *argp1 = 0 ;
34838 int res1 = 0 ;
34839 PyObject *swig_obj[1] ;
34840
34841 if (!args) SWIG_fail;
34842 swig_obj[0] = args;
34843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34844 if (!SWIG_IsOK(res1)) {
34845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34846 }
34847 arg1 = reinterpret_cast< wxWindow * >(argp1);
34848 {
34849 PyThreadState* __tstate = wxPyBeginAllowThreads();
34850 result = (bool)((wxWindow const *)arg1)->HasCapture();
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 {
34855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34856 }
34857 return resultobj;
34858 fail:
34859 return NULL;
34860 }
34861
34862
34863 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34864 PyObject *resultobj = 0;
34865 wxWindow *arg1 = (wxWindow *) 0 ;
34866 bool arg2 = (bool) true ;
34867 wxRect *arg3 = (wxRect *) NULL ;
34868 void *argp1 = 0 ;
34869 int res1 = 0 ;
34870 bool val2 ;
34871 int ecode2 = 0 ;
34872 void *argp3 = 0 ;
34873 int res3 = 0 ;
34874 PyObject * obj0 = 0 ;
34875 PyObject * obj1 = 0 ;
34876 PyObject * obj2 = 0 ;
34877 char * kwnames[] = {
34878 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34879 };
34880
34881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34883 if (!SWIG_IsOK(res1)) {
34884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34885 }
34886 arg1 = reinterpret_cast< wxWindow * >(argp1);
34887 if (obj1) {
34888 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34889 if (!SWIG_IsOK(ecode2)) {
34890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34891 }
34892 arg2 = static_cast< bool >(val2);
34893 }
34894 if (obj2) {
34895 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34896 if (!SWIG_IsOK(res3)) {
34897 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34898 }
34899 arg3 = reinterpret_cast< wxRect * >(argp3);
34900 }
34901 {
34902 PyThreadState* __tstate = wxPyBeginAllowThreads();
34903 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34904 wxPyEndAllowThreads(__tstate);
34905 if (PyErr_Occurred()) SWIG_fail;
34906 }
34907 resultobj = SWIG_Py_Void();
34908 return resultobj;
34909 fail:
34910 return NULL;
34911 }
34912
34913
34914 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34915 PyObject *resultobj = 0;
34916 wxWindow *arg1 = (wxWindow *) 0 ;
34917 wxRect *arg2 = 0 ;
34918 bool arg3 = (bool) true ;
34919 void *argp1 = 0 ;
34920 int res1 = 0 ;
34921 wxRect temp2 ;
34922 bool val3 ;
34923 int ecode3 = 0 ;
34924 PyObject * obj0 = 0 ;
34925 PyObject * obj1 = 0 ;
34926 PyObject * obj2 = 0 ;
34927 char * kwnames[] = {
34928 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34929 };
34930
34931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34933 if (!SWIG_IsOK(res1)) {
34934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34935 }
34936 arg1 = reinterpret_cast< wxWindow * >(argp1);
34937 {
34938 arg2 = &temp2;
34939 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34940 }
34941 if (obj2) {
34942 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34943 if (!SWIG_IsOK(ecode3)) {
34944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34945 }
34946 arg3 = static_cast< bool >(val3);
34947 }
34948 {
34949 PyThreadState* __tstate = wxPyBeginAllowThreads();
34950 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34951 wxPyEndAllowThreads(__tstate);
34952 if (PyErr_Occurred()) SWIG_fail;
34953 }
34954 resultobj = SWIG_Py_Void();
34955 return resultobj;
34956 fail:
34957 return NULL;
34958 }
34959
34960
34961 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34962 PyObject *resultobj = 0;
34963 wxWindow *arg1 = (wxWindow *) 0 ;
34964 void *argp1 = 0 ;
34965 int res1 = 0 ;
34966 PyObject *swig_obj[1] ;
34967
34968 if (!args) SWIG_fail;
34969 swig_obj[0] = args;
34970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34971 if (!SWIG_IsOK(res1)) {
34972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34973 }
34974 arg1 = reinterpret_cast< wxWindow * >(argp1);
34975 {
34976 PyThreadState* __tstate = wxPyBeginAllowThreads();
34977 (arg1)->Update();
34978 wxPyEndAllowThreads(__tstate);
34979 if (PyErr_Occurred()) SWIG_fail;
34980 }
34981 resultobj = SWIG_Py_Void();
34982 return resultobj;
34983 fail:
34984 return NULL;
34985 }
34986
34987
34988 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34989 PyObject *resultobj = 0;
34990 wxWindow *arg1 = (wxWindow *) 0 ;
34991 void *argp1 = 0 ;
34992 int res1 = 0 ;
34993 PyObject *swig_obj[1] ;
34994
34995 if (!args) SWIG_fail;
34996 swig_obj[0] = args;
34997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34998 if (!SWIG_IsOK(res1)) {
34999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35000 }
35001 arg1 = reinterpret_cast< wxWindow * >(argp1);
35002 {
35003 PyThreadState* __tstate = wxPyBeginAllowThreads();
35004 (arg1)->ClearBackground();
35005 wxPyEndAllowThreads(__tstate);
35006 if (PyErr_Occurred()) SWIG_fail;
35007 }
35008 resultobj = SWIG_Py_Void();
35009 return resultobj;
35010 fail:
35011 return NULL;
35012 }
35013
35014
35015 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35016 PyObject *resultobj = 0;
35017 wxWindow *arg1 = (wxWindow *) 0 ;
35018 void *argp1 = 0 ;
35019 int res1 = 0 ;
35020 PyObject *swig_obj[1] ;
35021
35022 if (!args) SWIG_fail;
35023 swig_obj[0] = args;
35024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35025 if (!SWIG_IsOK(res1)) {
35026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35027 }
35028 arg1 = reinterpret_cast< wxWindow * >(argp1);
35029 {
35030 PyThreadState* __tstate = wxPyBeginAllowThreads();
35031 (arg1)->Freeze();
35032 wxPyEndAllowThreads(__tstate);
35033 if (PyErr_Occurred()) SWIG_fail;
35034 }
35035 resultobj = SWIG_Py_Void();
35036 return resultobj;
35037 fail:
35038 return NULL;
35039 }
35040
35041
35042 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35043 PyObject *resultobj = 0;
35044 wxWindow *arg1 = (wxWindow *) 0 ;
35045 bool result;
35046 void *argp1 = 0 ;
35047 int res1 = 0 ;
35048 PyObject *swig_obj[1] ;
35049
35050 if (!args) SWIG_fail;
35051 swig_obj[0] = args;
35052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35053 if (!SWIG_IsOK(res1)) {
35054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35055 }
35056 arg1 = reinterpret_cast< wxWindow * >(argp1);
35057 {
35058 PyThreadState* __tstate = wxPyBeginAllowThreads();
35059 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35060 wxPyEndAllowThreads(__tstate);
35061 if (PyErr_Occurred()) SWIG_fail;
35062 }
35063 {
35064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35065 }
35066 return resultobj;
35067 fail:
35068 return NULL;
35069 }
35070
35071
35072 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35073 PyObject *resultobj = 0;
35074 wxWindow *arg1 = (wxWindow *) 0 ;
35075 void *argp1 = 0 ;
35076 int res1 = 0 ;
35077 PyObject *swig_obj[1] ;
35078
35079 if (!args) SWIG_fail;
35080 swig_obj[0] = args;
35081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35082 if (!SWIG_IsOK(res1)) {
35083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35084 }
35085 arg1 = reinterpret_cast< wxWindow * >(argp1);
35086 {
35087 PyThreadState* __tstate = wxPyBeginAllowThreads();
35088 (arg1)->Thaw();
35089 wxPyEndAllowThreads(__tstate);
35090 if (PyErr_Occurred()) SWIG_fail;
35091 }
35092 resultobj = SWIG_Py_Void();
35093 return resultobj;
35094 fail:
35095 return NULL;
35096 }
35097
35098
35099 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35100 PyObject *resultobj = 0;
35101 wxWindow *arg1 = (wxWindow *) 0 ;
35102 wxDC *arg2 = 0 ;
35103 void *argp1 = 0 ;
35104 int res1 = 0 ;
35105 void *argp2 = 0 ;
35106 int res2 = 0 ;
35107 PyObject * obj0 = 0 ;
35108 PyObject * obj1 = 0 ;
35109 char * kwnames[] = {
35110 (char *) "self",(char *) "dc", NULL
35111 };
35112
35113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35115 if (!SWIG_IsOK(res1)) {
35116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35117 }
35118 arg1 = reinterpret_cast< wxWindow * >(argp1);
35119 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35120 if (!SWIG_IsOK(res2)) {
35121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35122 }
35123 if (!argp2) {
35124 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35125 }
35126 arg2 = reinterpret_cast< wxDC * >(argp2);
35127 {
35128 PyThreadState* __tstate = wxPyBeginAllowThreads();
35129 (arg1)->PrepareDC(*arg2);
35130 wxPyEndAllowThreads(__tstate);
35131 if (PyErr_Occurred()) SWIG_fail;
35132 }
35133 resultobj = SWIG_Py_Void();
35134 return resultobj;
35135 fail:
35136 return NULL;
35137 }
35138
35139
35140 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35141 PyObject *resultobj = 0;
35142 wxWindow *arg1 = (wxWindow *) 0 ;
35143 wxRegion *result = 0 ;
35144 void *argp1 = 0 ;
35145 int res1 = 0 ;
35146 PyObject *swig_obj[1] ;
35147
35148 if (!args) SWIG_fail;
35149 swig_obj[0] = args;
35150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35151 if (!SWIG_IsOK(res1)) {
35152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35153 }
35154 arg1 = reinterpret_cast< wxWindow * >(argp1);
35155 {
35156 PyThreadState* __tstate = wxPyBeginAllowThreads();
35157 {
35158 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35159 result = (wxRegion *) &_result_ref;
35160 }
35161 wxPyEndAllowThreads(__tstate);
35162 if (PyErr_Occurred()) SWIG_fail;
35163 }
35164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35165 return resultobj;
35166 fail:
35167 return NULL;
35168 }
35169
35170
35171 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35172 PyObject *resultobj = 0;
35173 wxWindow *arg1 = (wxWindow *) 0 ;
35174 wxRect result;
35175 void *argp1 = 0 ;
35176 int res1 = 0 ;
35177 PyObject *swig_obj[1] ;
35178
35179 if (!args) SWIG_fail;
35180 swig_obj[0] = args;
35181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35182 if (!SWIG_IsOK(res1)) {
35183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35184 }
35185 arg1 = reinterpret_cast< wxWindow * >(argp1);
35186 {
35187 PyThreadState* __tstate = wxPyBeginAllowThreads();
35188 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35189 wxPyEndAllowThreads(__tstate);
35190 if (PyErr_Occurred()) SWIG_fail;
35191 }
35192 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35193 return resultobj;
35194 fail:
35195 return NULL;
35196 }
35197
35198
35199 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35200 PyObject *resultobj = 0;
35201 wxWindow *arg1 = (wxWindow *) 0 ;
35202 int arg2 ;
35203 int arg3 ;
35204 int arg4 = (int) 1 ;
35205 int arg5 = (int) 1 ;
35206 bool result;
35207 void *argp1 = 0 ;
35208 int res1 = 0 ;
35209 int val2 ;
35210 int ecode2 = 0 ;
35211 int val3 ;
35212 int ecode3 = 0 ;
35213 int val4 ;
35214 int ecode4 = 0 ;
35215 int val5 ;
35216 int ecode5 = 0 ;
35217 PyObject * obj0 = 0 ;
35218 PyObject * obj1 = 0 ;
35219 PyObject * obj2 = 0 ;
35220 PyObject * obj3 = 0 ;
35221 PyObject * obj4 = 0 ;
35222 char * kwnames[] = {
35223 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35224 };
35225
35226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35228 if (!SWIG_IsOK(res1)) {
35229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35230 }
35231 arg1 = reinterpret_cast< wxWindow * >(argp1);
35232 ecode2 = SWIG_AsVal_int(obj1, &val2);
35233 if (!SWIG_IsOK(ecode2)) {
35234 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35235 }
35236 arg2 = static_cast< int >(val2);
35237 ecode3 = SWIG_AsVal_int(obj2, &val3);
35238 if (!SWIG_IsOK(ecode3)) {
35239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35240 }
35241 arg3 = static_cast< int >(val3);
35242 if (obj3) {
35243 ecode4 = SWIG_AsVal_int(obj3, &val4);
35244 if (!SWIG_IsOK(ecode4)) {
35245 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35246 }
35247 arg4 = static_cast< int >(val4);
35248 }
35249 if (obj4) {
35250 ecode5 = SWIG_AsVal_int(obj4, &val5);
35251 if (!SWIG_IsOK(ecode5)) {
35252 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35253 }
35254 arg5 = static_cast< int >(val5);
35255 }
35256 {
35257 PyThreadState* __tstate = wxPyBeginAllowThreads();
35258 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35259 wxPyEndAllowThreads(__tstate);
35260 if (PyErr_Occurred()) SWIG_fail;
35261 }
35262 {
35263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35264 }
35265 return resultobj;
35266 fail:
35267 return NULL;
35268 }
35269
35270
35271 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35272 PyObject *resultobj = 0;
35273 wxWindow *arg1 = (wxWindow *) 0 ;
35274 wxPoint *arg2 = 0 ;
35275 bool result;
35276 void *argp1 = 0 ;
35277 int res1 = 0 ;
35278 wxPoint temp2 ;
35279 PyObject * obj0 = 0 ;
35280 PyObject * obj1 = 0 ;
35281 char * kwnames[] = {
35282 (char *) "self",(char *) "pt", NULL
35283 };
35284
35285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35287 if (!SWIG_IsOK(res1)) {
35288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35289 }
35290 arg1 = reinterpret_cast< wxWindow * >(argp1);
35291 {
35292 arg2 = &temp2;
35293 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35294 }
35295 {
35296 PyThreadState* __tstate = wxPyBeginAllowThreads();
35297 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35298 wxPyEndAllowThreads(__tstate);
35299 if (PyErr_Occurred()) SWIG_fail;
35300 }
35301 {
35302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35303 }
35304 return resultobj;
35305 fail:
35306 return NULL;
35307 }
35308
35309
35310 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35311 PyObject *resultobj = 0;
35312 wxWindow *arg1 = (wxWindow *) 0 ;
35313 wxRect *arg2 = 0 ;
35314 bool result;
35315 void *argp1 = 0 ;
35316 int res1 = 0 ;
35317 wxRect temp2 ;
35318 PyObject * obj0 = 0 ;
35319 PyObject * obj1 = 0 ;
35320 char * kwnames[] = {
35321 (char *) "self",(char *) "rect", NULL
35322 };
35323
35324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35326 if (!SWIG_IsOK(res1)) {
35327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35328 }
35329 arg1 = reinterpret_cast< wxWindow * >(argp1);
35330 {
35331 arg2 = &temp2;
35332 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35333 }
35334 {
35335 PyThreadState* __tstate = wxPyBeginAllowThreads();
35336 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35337 wxPyEndAllowThreads(__tstate);
35338 if (PyErr_Occurred()) SWIG_fail;
35339 }
35340 {
35341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35342 }
35343 return resultobj;
35344 fail:
35345 return NULL;
35346 }
35347
35348
35349 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35350 PyObject *resultobj = 0;
35351 wxWindow *arg1 = (wxWindow *) 0 ;
35352 SwigValueWrapper<wxVisualAttributes > result;
35353 void *argp1 = 0 ;
35354 int res1 = 0 ;
35355 PyObject *swig_obj[1] ;
35356
35357 if (!args) SWIG_fail;
35358 swig_obj[0] = args;
35359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35360 if (!SWIG_IsOK(res1)) {
35361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35362 }
35363 arg1 = reinterpret_cast< wxWindow * >(argp1);
35364 {
35365 PyThreadState* __tstate = wxPyBeginAllowThreads();
35366 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35367 wxPyEndAllowThreads(__tstate);
35368 if (PyErr_Occurred()) SWIG_fail;
35369 }
35370 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35371 return resultobj;
35372 fail:
35373 return NULL;
35374 }
35375
35376
35377 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35378 PyObject *resultobj = 0;
35379 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35380 SwigValueWrapper<wxVisualAttributes > result;
35381 int val1 ;
35382 int ecode1 = 0 ;
35383 PyObject * obj0 = 0 ;
35384 char * kwnames[] = {
35385 (char *) "variant", NULL
35386 };
35387
35388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35389 if (obj0) {
35390 ecode1 = SWIG_AsVal_int(obj0, &val1);
35391 if (!SWIG_IsOK(ecode1)) {
35392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35393 }
35394 arg1 = static_cast< wxWindowVariant >(val1);
35395 }
35396 {
35397 if (!wxPyCheckForApp()) SWIG_fail;
35398 PyThreadState* __tstate = wxPyBeginAllowThreads();
35399 result = wxWindow::GetClassDefaultAttributes(arg1);
35400 wxPyEndAllowThreads(__tstate);
35401 if (PyErr_Occurred()) SWIG_fail;
35402 }
35403 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35404 return resultobj;
35405 fail:
35406 return NULL;
35407 }
35408
35409
35410 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35411 PyObject *resultobj = 0;
35412 wxWindow *arg1 = (wxWindow *) 0 ;
35413 wxColour *arg2 = 0 ;
35414 bool result;
35415 void *argp1 = 0 ;
35416 int res1 = 0 ;
35417 wxColour temp2 ;
35418 PyObject * obj0 = 0 ;
35419 PyObject * obj1 = 0 ;
35420 char * kwnames[] = {
35421 (char *) "self",(char *) "colour", NULL
35422 };
35423
35424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35426 if (!SWIG_IsOK(res1)) {
35427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35428 }
35429 arg1 = reinterpret_cast< wxWindow * >(argp1);
35430 {
35431 arg2 = &temp2;
35432 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35433 }
35434 {
35435 PyThreadState* __tstate = wxPyBeginAllowThreads();
35436 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35437 wxPyEndAllowThreads(__tstate);
35438 if (PyErr_Occurred()) SWIG_fail;
35439 }
35440 {
35441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35442 }
35443 return resultobj;
35444 fail:
35445 return NULL;
35446 }
35447
35448
35449 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35450 PyObject *resultobj = 0;
35451 wxWindow *arg1 = (wxWindow *) 0 ;
35452 wxColour *arg2 = 0 ;
35453 void *argp1 = 0 ;
35454 int res1 = 0 ;
35455 wxColour temp2 ;
35456 PyObject * obj0 = 0 ;
35457 PyObject * obj1 = 0 ;
35458 char * kwnames[] = {
35459 (char *) "self",(char *) "colour", NULL
35460 };
35461
35462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35464 if (!SWIG_IsOK(res1)) {
35465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35466 }
35467 arg1 = reinterpret_cast< wxWindow * >(argp1);
35468 {
35469 arg2 = &temp2;
35470 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35471 }
35472 {
35473 PyThreadState* __tstate = wxPyBeginAllowThreads();
35474 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35475 wxPyEndAllowThreads(__tstate);
35476 if (PyErr_Occurred()) SWIG_fail;
35477 }
35478 resultobj = SWIG_Py_Void();
35479 return resultobj;
35480 fail:
35481 return NULL;
35482 }
35483
35484
35485 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35486 PyObject *resultobj = 0;
35487 wxWindow *arg1 = (wxWindow *) 0 ;
35488 wxColour *arg2 = 0 ;
35489 bool result;
35490 void *argp1 = 0 ;
35491 int res1 = 0 ;
35492 wxColour temp2 ;
35493 PyObject * obj0 = 0 ;
35494 PyObject * obj1 = 0 ;
35495 char * kwnames[] = {
35496 (char *) "self",(char *) "colour", NULL
35497 };
35498
35499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35501 if (!SWIG_IsOK(res1)) {
35502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35503 }
35504 arg1 = reinterpret_cast< wxWindow * >(argp1);
35505 {
35506 arg2 = &temp2;
35507 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35508 }
35509 {
35510 PyThreadState* __tstate = wxPyBeginAllowThreads();
35511 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35512 wxPyEndAllowThreads(__tstate);
35513 if (PyErr_Occurred()) SWIG_fail;
35514 }
35515 {
35516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35517 }
35518 return resultobj;
35519 fail:
35520 return NULL;
35521 }
35522
35523
35524 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35525 PyObject *resultobj = 0;
35526 wxWindow *arg1 = (wxWindow *) 0 ;
35527 wxColour *arg2 = 0 ;
35528 void *argp1 = 0 ;
35529 int res1 = 0 ;
35530 wxColour temp2 ;
35531 PyObject * obj0 = 0 ;
35532 PyObject * obj1 = 0 ;
35533 char * kwnames[] = {
35534 (char *) "self",(char *) "colour", NULL
35535 };
35536
35537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35539 if (!SWIG_IsOK(res1)) {
35540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35541 }
35542 arg1 = reinterpret_cast< wxWindow * >(argp1);
35543 {
35544 arg2 = &temp2;
35545 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35546 }
35547 {
35548 PyThreadState* __tstate = wxPyBeginAllowThreads();
35549 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35550 wxPyEndAllowThreads(__tstate);
35551 if (PyErr_Occurred()) SWIG_fail;
35552 }
35553 resultobj = SWIG_Py_Void();
35554 return resultobj;
35555 fail:
35556 return NULL;
35557 }
35558
35559
35560 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35561 PyObject *resultobj = 0;
35562 wxWindow *arg1 = (wxWindow *) 0 ;
35563 wxColour result;
35564 void *argp1 = 0 ;
35565 int res1 = 0 ;
35566 PyObject *swig_obj[1] ;
35567
35568 if (!args) SWIG_fail;
35569 swig_obj[0] = args;
35570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35571 if (!SWIG_IsOK(res1)) {
35572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35573 }
35574 arg1 = reinterpret_cast< wxWindow * >(argp1);
35575 {
35576 PyThreadState* __tstate = wxPyBeginAllowThreads();
35577 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35578 wxPyEndAllowThreads(__tstate);
35579 if (PyErr_Occurred()) SWIG_fail;
35580 }
35581 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35582 return resultobj;
35583 fail:
35584 return NULL;
35585 }
35586
35587
35588 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35589 PyObject *resultobj = 0;
35590 wxWindow *arg1 = (wxWindow *) 0 ;
35591 wxColour result;
35592 void *argp1 = 0 ;
35593 int res1 = 0 ;
35594 PyObject *swig_obj[1] ;
35595
35596 if (!args) SWIG_fail;
35597 swig_obj[0] = args;
35598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35599 if (!SWIG_IsOK(res1)) {
35600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35601 }
35602 arg1 = reinterpret_cast< wxWindow * >(argp1);
35603 {
35604 PyThreadState* __tstate = wxPyBeginAllowThreads();
35605 result = ((wxWindow const *)arg1)->GetForegroundColour();
35606 wxPyEndAllowThreads(__tstate);
35607 if (PyErr_Occurred()) SWIG_fail;
35608 }
35609 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35610 return resultobj;
35611 fail:
35612 return NULL;
35613 }
35614
35615
35616 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35617 PyObject *resultobj = 0;
35618 wxWindow *arg1 = (wxWindow *) 0 ;
35619 bool result;
35620 void *argp1 = 0 ;
35621 int res1 = 0 ;
35622 PyObject *swig_obj[1] ;
35623
35624 if (!args) SWIG_fail;
35625 swig_obj[0] = args;
35626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35627 if (!SWIG_IsOK(res1)) {
35628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35629 }
35630 arg1 = reinterpret_cast< wxWindow * >(argp1);
35631 {
35632 PyThreadState* __tstate = wxPyBeginAllowThreads();
35633 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35634 wxPyEndAllowThreads(__tstate);
35635 if (PyErr_Occurred()) SWIG_fail;
35636 }
35637 {
35638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35639 }
35640 return resultobj;
35641 fail:
35642 return NULL;
35643 }
35644
35645
35646 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35647 PyObject *resultobj = 0;
35648 wxWindow *arg1 = (wxWindow *) 0 ;
35649 bool result;
35650 void *argp1 = 0 ;
35651 int res1 = 0 ;
35652 PyObject *swig_obj[1] ;
35653
35654 if (!args) SWIG_fail;
35655 swig_obj[0] = args;
35656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35657 if (!SWIG_IsOK(res1)) {
35658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35659 }
35660 arg1 = reinterpret_cast< wxWindow * >(argp1);
35661 {
35662 PyThreadState* __tstate = wxPyBeginAllowThreads();
35663 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35664 wxPyEndAllowThreads(__tstate);
35665 if (PyErr_Occurred()) SWIG_fail;
35666 }
35667 {
35668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35669 }
35670 return resultobj;
35671 fail:
35672 return NULL;
35673 }
35674
35675
35676 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35677 PyObject *resultobj = 0;
35678 wxWindow *arg1 = (wxWindow *) 0 ;
35679 wxBackgroundStyle arg2 ;
35680 bool result;
35681 void *argp1 = 0 ;
35682 int res1 = 0 ;
35683 int val2 ;
35684 int ecode2 = 0 ;
35685 PyObject * obj0 = 0 ;
35686 PyObject * obj1 = 0 ;
35687 char * kwnames[] = {
35688 (char *) "self",(char *) "style", NULL
35689 };
35690
35691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35693 if (!SWIG_IsOK(res1)) {
35694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35695 }
35696 arg1 = reinterpret_cast< wxWindow * >(argp1);
35697 ecode2 = SWIG_AsVal_int(obj1, &val2);
35698 if (!SWIG_IsOK(ecode2)) {
35699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35700 }
35701 arg2 = static_cast< wxBackgroundStyle >(val2);
35702 {
35703 PyThreadState* __tstate = wxPyBeginAllowThreads();
35704 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35705 wxPyEndAllowThreads(__tstate);
35706 if (PyErr_Occurred()) SWIG_fail;
35707 }
35708 {
35709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35710 }
35711 return resultobj;
35712 fail:
35713 return NULL;
35714 }
35715
35716
35717 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35718 PyObject *resultobj = 0;
35719 wxWindow *arg1 = (wxWindow *) 0 ;
35720 wxBackgroundStyle result;
35721 void *argp1 = 0 ;
35722 int res1 = 0 ;
35723 PyObject *swig_obj[1] ;
35724
35725 if (!args) SWIG_fail;
35726 swig_obj[0] = args;
35727 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35728 if (!SWIG_IsOK(res1)) {
35729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35730 }
35731 arg1 = reinterpret_cast< wxWindow * >(argp1);
35732 {
35733 PyThreadState* __tstate = wxPyBeginAllowThreads();
35734 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35735 wxPyEndAllowThreads(__tstate);
35736 if (PyErr_Occurred()) SWIG_fail;
35737 }
35738 resultobj = SWIG_From_int(static_cast< int >(result));
35739 return resultobj;
35740 fail:
35741 return NULL;
35742 }
35743
35744
35745 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35746 PyObject *resultobj = 0;
35747 wxWindow *arg1 = (wxWindow *) 0 ;
35748 bool result;
35749 void *argp1 = 0 ;
35750 int res1 = 0 ;
35751 PyObject *swig_obj[1] ;
35752
35753 if (!args) SWIG_fail;
35754 swig_obj[0] = args;
35755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35756 if (!SWIG_IsOK(res1)) {
35757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35758 }
35759 arg1 = reinterpret_cast< wxWindow * >(argp1);
35760 {
35761 PyThreadState* __tstate = wxPyBeginAllowThreads();
35762 result = (bool)(arg1)->HasTransparentBackground();
35763 wxPyEndAllowThreads(__tstate);
35764 if (PyErr_Occurred()) SWIG_fail;
35765 }
35766 {
35767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35768 }
35769 return resultobj;
35770 fail:
35771 return NULL;
35772 }
35773
35774
35775 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35776 PyObject *resultobj = 0;
35777 wxWindow *arg1 = (wxWindow *) 0 ;
35778 wxCursor *arg2 = 0 ;
35779 bool result;
35780 void *argp1 = 0 ;
35781 int res1 = 0 ;
35782 void *argp2 = 0 ;
35783 int res2 = 0 ;
35784 PyObject * obj0 = 0 ;
35785 PyObject * obj1 = 0 ;
35786 char * kwnames[] = {
35787 (char *) "self",(char *) "cursor", NULL
35788 };
35789
35790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35792 if (!SWIG_IsOK(res1)) {
35793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35794 }
35795 arg1 = reinterpret_cast< wxWindow * >(argp1);
35796 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35797 if (!SWIG_IsOK(res2)) {
35798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35799 }
35800 if (!argp2) {
35801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35802 }
35803 arg2 = reinterpret_cast< wxCursor * >(argp2);
35804 {
35805 PyThreadState* __tstate = wxPyBeginAllowThreads();
35806 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35807 wxPyEndAllowThreads(__tstate);
35808 if (PyErr_Occurred()) SWIG_fail;
35809 }
35810 {
35811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35812 }
35813 return resultobj;
35814 fail:
35815 return NULL;
35816 }
35817
35818
35819 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35820 PyObject *resultobj = 0;
35821 wxWindow *arg1 = (wxWindow *) 0 ;
35822 wxCursor result;
35823 void *argp1 = 0 ;
35824 int res1 = 0 ;
35825 PyObject *swig_obj[1] ;
35826
35827 if (!args) SWIG_fail;
35828 swig_obj[0] = args;
35829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35830 if (!SWIG_IsOK(res1)) {
35831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35832 }
35833 arg1 = reinterpret_cast< wxWindow * >(argp1);
35834 {
35835 PyThreadState* __tstate = wxPyBeginAllowThreads();
35836 result = (arg1)->GetCursor();
35837 wxPyEndAllowThreads(__tstate);
35838 if (PyErr_Occurred()) SWIG_fail;
35839 }
35840 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35841 return resultobj;
35842 fail:
35843 return NULL;
35844 }
35845
35846
35847 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35848 PyObject *resultobj = 0;
35849 wxWindow *arg1 = (wxWindow *) 0 ;
35850 wxFont *arg2 = 0 ;
35851 bool result;
35852 void *argp1 = 0 ;
35853 int res1 = 0 ;
35854 void *argp2 = 0 ;
35855 int res2 = 0 ;
35856 PyObject * obj0 = 0 ;
35857 PyObject * obj1 = 0 ;
35858 char * kwnames[] = {
35859 (char *) "self",(char *) "font", NULL
35860 };
35861
35862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35864 if (!SWIG_IsOK(res1)) {
35865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35866 }
35867 arg1 = reinterpret_cast< wxWindow * >(argp1);
35868 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35869 if (!SWIG_IsOK(res2)) {
35870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35871 }
35872 if (!argp2) {
35873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35874 }
35875 arg2 = reinterpret_cast< wxFont * >(argp2);
35876 {
35877 PyThreadState* __tstate = wxPyBeginAllowThreads();
35878 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35879 wxPyEndAllowThreads(__tstate);
35880 if (PyErr_Occurred()) SWIG_fail;
35881 }
35882 {
35883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35884 }
35885 return resultobj;
35886 fail:
35887 return NULL;
35888 }
35889
35890
35891 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35892 PyObject *resultobj = 0;
35893 wxWindow *arg1 = (wxWindow *) 0 ;
35894 wxFont *arg2 = 0 ;
35895 void *argp1 = 0 ;
35896 int res1 = 0 ;
35897 void *argp2 = 0 ;
35898 int res2 = 0 ;
35899 PyObject * obj0 = 0 ;
35900 PyObject * obj1 = 0 ;
35901 char * kwnames[] = {
35902 (char *) "self",(char *) "font", NULL
35903 };
35904
35905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35907 if (!SWIG_IsOK(res1)) {
35908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35909 }
35910 arg1 = reinterpret_cast< wxWindow * >(argp1);
35911 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35912 if (!SWIG_IsOK(res2)) {
35913 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35914 }
35915 if (!argp2) {
35916 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35917 }
35918 arg2 = reinterpret_cast< wxFont * >(argp2);
35919 {
35920 PyThreadState* __tstate = wxPyBeginAllowThreads();
35921 (arg1)->SetOwnFont((wxFont const &)*arg2);
35922 wxPyEndAllowThreads(__tstate);
35923 if (PyErr_Occurred()) SWIG_fail;
35924 }
35925 resultobj = SWIG_Py_Void();
35926 return resultobj;
35927 fail:
35928 return NULL;
35929 }
35930
35931
35932 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35933 PyObject *resultobj = 0;
35934 wxWindow *arg1 = (wxWindow *) 0 ;
35935 wxFont result;
35936 void *argp1 = 0 ;
35937 int res1 = 0 ;
35938 PyObject *swig_obj[1] ;
35939
35940 if (!args) SWIG_fail;
35941 swig_obj[0] = args;
35942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35943 if (!SWIG_IsOK(res1)) {
35944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35945 }
35946 arg1 = reinterpret_cast< wxWindow * >(argp1);
35947 {
35948 PyThreadState* __tstate = wxPyBeginAllowThreads();
35949 result = (arg1)->GetFont();
35950 wxPyEndAllowThreads(__tstate);
35951 if (PyErr_Occurred()) SWIG_fail;
35952 }
35953 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35954 return resultobj;
35955 fail:
35956 return NULL;
35957 }
35958
35959
35960 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35961 PyObject *resultobj = 0;
35962 wxWindow *arg1 = (wxWindow *) 0 ;
35963 wxCaret *arg2 = (wxCaret *) 0 ;
35964 void *argp1 = 0 ;
35965 int res1 = 0 ;
35966 int res2 = 0 ;
35967 PyObject * obj0 = 0 ;
35968 PyObject * obj1 = 0 ;
35969 char * kwnames[] = {
35970 (char *) "self",(char *) "caret", NULL
35971 };
35972
35973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35975 if (!SWIG_IsOK(res1)) {
35976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35977 }
35978 arg1 = reinterpret_cast< wxWindow * >(argp1);
35979 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35980 if (!SWIG_IsOK(res2)) {
35981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35982 }
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 (arg1)->SetCaret(arg2);
35986 wxPyEndAllowThreads(__tstate);
35987 if (PyErr_Occurred()) SWIG_fail;
35988 }
35989 resultobj = SWIG_Py_Void();
35990 return resultobj;
35991 fail:
35992 return NULL;
35993 }
35994
35995
35996 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35997 PyObject *resultobj = 0;
35998 wxWindow *arg1 = (wxWindow *) 0 ;
35999 wxCaret *result = 0 ;
36000 void *argp1 = 0 ;
36001 int res1 = 0 ;
36002 PyObject *swig_obj[1] ;
36003
36004 if (!args) SWIG_fail;
36005 swig_obj[0] = args;
36006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36007 if (!SWIG_IsOK(res1)) {
36008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36009 }
36010 arg1 = reinterpret_cast< wxWindow * >(argp1);
36011 {
36012 PyThreadState* __tstate = wxPyBeginAllowThreads();
36013 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36014 wxPyEndAllowThreads(__tstate);
36015 if (PyErr_Occurred()) SWIG_fail;
36016 }
36017 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36018 return resultobj;
36019 fail:
36020 return NULL;
36021 }
36022
36023
36024 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36025 PyObject *resultobj = 0;
36026 wxWindow *arg1 = (wxWindow *) 0 ;
36027 int result;
36028 void *argp1 = 0 ;
36029 int res1 = 0 ;
36030 PyObject *swig_obj[1] ;
36031
36032 if (!args) SWIG_fail;
36033 swig_obj[0] = args;
36034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36035 if (!SWIG_IsOK(res1)) {
36036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36037 }
36038 arg1 = reinterpret_cast< wxWindow * >(argp1);
36039 {
36040 PyThreadState* __tstate = wxPyBeginAllowThreads();
36041 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36042 wxPyEndAllowThreads(__tstate);
36043 if (PyErr_Occurred()) SWIG_fail;
36044 }
36045 resultobj = SWIG_From_int(static_cast< int >(result));
36046 return resultobj;
36047 fail:
36048 return NULL;
36049 }
36050
36051
36052 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36053 PyObject *resultobj = 0;
36054 wxWindow *arg1 = (wxWindow *) 0 ;
36055 int result;
36056 void *argp1 = 0 ;
36057 int res1 = 0 ;
36058 PyObject *swig_obj[1] ;
36059
36060 if (!args) SWIG_fail;
36061 swig_obj[0] = args;
36062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36063 if (!SWIG_IsOK(res1)) {
36064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36065 }
36066 arg1 = reinterpret_cast< wxWindow * >(argp1);
36067 {
36068 PyThreadState* __tstate = wxPyBeginAllowThreads();
36069 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36070 wxPyEndAllowThreads(__tstate);
36071 if (PyErr_Occurred()) SWIG_fail;
36072 }
36073 resultobj = SWIG_From_int(static_cast< int >(result));
36074 return resultobj;
36075 fail:
36076 return NULL;
36077 }
36078
36079
36080 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36081 PyObject *resultobj = 0;
36082 wxWindow *arg1 = (wxWindow *) 0 ;
36083 wxString *arg2 = 0 ;
36084 int *arg3 = (int *) 0 ;
36085 int *arg4 = (int *) 0 ;
36086 void *argp1 = 0 ;
36087 int res1 = 0 ;
36088 bool temp2 = false ;
36089 int temp3 ;
36090 int res3 = SWIG_TMPOBJ ;
36091 int temp4 ;
36092 int res4 = SWIG_TMPOBJ ;
36093 PyObject * obj0 = 0 ;
36094 PyObject * obj1 = 0 ;
36095 char * kwnames[] = {
36096 (char *) "self",(char *) "string", NULL
36097 };
36098
36099 arg3 = &temp3;
36100 arg4 = &temp4;
36101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36103 if (!SWIG_IsOK(res1)) {
36104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36105 }
36106 arg1 = reinterpret_cast< wxWindow * >(argp1);
36107 {
36108 arg2 = wxString_in_helper(obj1);
36109 if (arg2 == NULL) SWIG_fail;
36110 temp2 = true;
36111 }
36112 {
36113 PyThreadState* __tstate = wxPyBeginAllowThreads();
36114 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36115 wxPyEndAllowThreads(__tstate);
36116 if (PyErr_Occurred()) SWIG_fail;
36117 }
36118 resultobj = SWIG_Py_Void();
36119 if (SWIG_IsTmpObj(res3)) {
36120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36121 } else {
36122 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36124 }
36125 if (SWIG_IsTmpObj(res4)) {
36126 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36127 } else {
36128 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36130 }
36131 {
36132 if (temp2)
36133 delete arg2;
36134 }
36135 return resultobj;
36136 fail:
36137 {
36138 if (temp2)
36139 delete arg2;
36140 }
36141 return NULL;
36142 }
36143
36144
36145 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36146 PyObject *resultobj = 0;
36147 wxWindow *arg1 = (wxWindow *) 0 ;
36148 wxString *arg2 = 0 ;
36149 int *arg3 = (int *) 0 ;
36150 int *arg4 = (int *) 0 ;
36151 int *arg5 = (int *) 0 ;
36152 int *arg6 = (int *) 0 ;
36153 wxFont *arg7 = (wxFont *) NULL ;
36154 void *argp1 = 0 ;
36155 int res1 = 0 ;
36156 bool temp2 = false ;
36157 int temp3 ;
36158 int res3 = SWIG_TMPOBJ ;
36159 int temp4 ;
36160 int res4 = SWIG_TMPOBJ ;
36161 int temp5 ;
36162 int res5 = SWIG_TMPOBJ ;
36163 int temp6 ;
36164 int res6 = SWIG_TMPOBJ ;
36165 void *argp7 = 0 ;
36166 int res7 = 0 ;
36167 PyObject * obj0 = 0 ;
36168 PyObject * obj1 = 0 ;
36169 PyObject * obj2 = 0 ;
36170 char * kwnames[] = {
36171 (char *) "self",(char *) "string",(char *) "font", NULL
36172 };
36173
36174 arg3 = &temp3;
36175 arg4 = &temp4;
36176 arg5 = &temp5;
36177 arg6 = &temp6;
36178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36180 if (!SWIG_IsOK(res1)) {
36181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36182 }
36183 arg1 = reinterpret_cast< wxWindow * >(argp1);
36184 {
36185 arg2 = wxString_in_helper(obj1);
36186 if (arg2 == NULL) SWIG_fail;
36187 temp2 = true;
36188 }
36189 if (obj2) {
36190 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36191 if (!SWIG_IsOK(res7)) {
36192 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36193 }
36194 arg7 = reinterpret_cast< wxFont * >(argp7);
36195 }
36196 {
36197 PyThreadState* __tstate = wxPyBeginAllowThreads();
36198 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36199 wxPyEndAllowThreads(__tstate);
36200 if (PyErr_Occurred()) SWIG_fail;
36201 }
36202 resultobj = SWIG_Py_Void();
36203 if (SWIG_IsTmpObj(res3)) {
36204 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36205 } else {
36206 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36207 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36208 }
36209 if (SWIG_IsTmpObj(res4)) {
36210 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36211 } else {
36212 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36213 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36214 }
36215 if (SWIG_IsTmpObj(res5)) {
36216 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36217 } else {
36218 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36220 }
36221 if (SWIG_IsTmpObj(res6)) {
36222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36223 } else {
36224 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36225 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36226 }
36227 {
36228 if (temp2)
36229 delete arg2;
36230 }
36231 return resultobj;
36232 fail:
36233 {
36234 if (temp2)
36235 delete arg2;
36236 }
36237 return NULL;
36238 }
36239
36240
36241 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36242 PyObject *resultobj = 0;
36243 wxWindow *arg1 = (wxWindow *) 0 ;
36244 int *arg2 = (int *) 0 ;
36245 int *arg3 = (int *) 0 ;
36246 void *argp1 = 0 ;
36247 int res1 = 0 ;
36248 int temp2 ;
36249 int res2 = 0 ;
36250 int temp3 ;
36251 int res3 = 0 ;
36252 PyObject * obj0 = 0 ;
36253 PyObject * obj1 = 0 ;
36254 PyObject * obj2 = 0 ;
36255 char * kwnames[] = {
36256 (char *) "self",(char *) "x",(char *) "y", NULL
36257 };
36258
36259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36261 if (!SWIG_IsOK(res1)) {
36262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36263 }
36264 arg1 = reinterpret_cast< wxWindow * >(argp1);
36265 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36266 int val;
36267 int ecode = SWIG_AsVal_int(obj1, &val);
36268 if (!SWIG_IsOK(ecode)) {
36269 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36270 }
36271 temp2 = static_cast< int >(val);
36272 arg2 = &temp2;
36273 res2 = SWIG_AddTmpMask(ecode);
36274 }
36275 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36276 int val;
36277 int ecode = SWIG_AsVal_int(obj2, &val);
36278 if (!SWIG_IsOK(ecode)) {
36279 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36280 }
36281 temp3 = static_cast< int >(val);
36282 arg3 = &temp3;
36283 res3 = SWIG_AddTmpMask(ecode);
36284 }
36285 {
36286 PyThreadState* __tstate = wxPyBeginAllowThreads();
36287 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36288 wxPyEndAllowThreads(__tstate);
36289 if (PyErr_Occurred()) SWIG_fail;
36290 }
36291 resultobj = SWIG_Py_Void();
36292 if (SWIG_IsTmpObj(res2)) {
36293 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36294 } else {
36295 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36296 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36297 }
36298 if (SWIG_IsTmpObj(res3)) {
36299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36300 } else {
36301 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36303 }
36304 return resultobj;
36305 fail:
36306 return NULL;
36307 }
36308
36309
36310 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36311 PyObject *resultobj = 0;
36312 wxWindow *arg1 = (wxWindow *) 0 ;
36313 int *arg2 = (int *) 0 ;
36314 int *arg3 = (int *) 0 ;
36315 void *argp1 = 0 ;
36316 int res1 = 0 ;
36317 int temp2 ;
36318 int res2 = 0 ;
36319 int temp3 ;
36320 int res3 = 0 ;
36321 PyObject * obj0 = 0 ;
36322 PyObject * obj1 = 0 ;
36323 PyObject * obj2 = 0 ;
36324 char * kwnames[] = {
36325 (char *) "self",(char *) "x",(char *) "y", NULL
36326 };
36327
36328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36330 if (!SWIG_IsOK(res1)) {
36331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36332 }
36333 arg1 = reinterpret_cast< wxWindow * >(argp1);
36334 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36335 int val;
36336 int ecode = SWIG_AsVal_int(obj1, &val);
36337 if (!SWIG_IsOK(ecode)) {
36338 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36339 }
36340 temp2 = static_cast< int >(val);
36341 arg2 = &temp2;
36342 res2 = SWIG_AddTmpMask(ecode);
36343 }
36344 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36345 int val;
36346 int ecode = SWIG_AsVal_int(obj2, &val);
36347 if (!SWIG_IsOK(ecode)) {
36348 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36349 }
36350 temp3 = static_cast< int >(val);
36351 arg3 = &temp3;
36352 res3 = SWIG_AddTmpMask(ecode);
36353 }
36354 {
36355 PyThreadState* __tstate = wxPyBeginAllowThreads();
36356 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36357 wxPyEndAllowThreads(__tstate);
36358 if (PyErr_Occurred()) SWIG_fail;
36359 }
36360 resultobj = SWIG_Py_Void();
36361 if (SWIG_IsTmpObj(res2)) {
36362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36363 } else {
36364 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36366 }
36367 if (SWIG_IsTmpObj(res3)) {
36368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36369 } else {
36370 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36372 }
36373 return resultobj;
36374 fail:
36375 return NULL;
36376 }
36377
36378
36379 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36380 PyObject *resultobj = 0;
36381 wxWindow *arg1 = (wxWindow *) 0 ;
36382 wxPoint *arg2 = 0 ;
36383 wxPoint result;
36384 void *argp1 = 0 ;
36385 int res1 = 0 ;
36386 wxPoint temp2 ;
36387 PyObject * obj0 = 0 ;
36388 PyObject * obj1 = 0 ;
36389 char * kwnames[] = {
36390 (char *) "self",(char *) "pt", NULL
36391 };
36392
36393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36395 if (!SWIG_IsOK(res1)) {
36396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36397 }
36398 arg1 = reinterpret_cast< wxWindow * >(argp1);
36399 {
36400 arg2 = &temp2;
36401 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36402 }
36403 {
36404 PyThreadState* __tstate = wxPyBeginAllowThreads();
36405 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36406 wxPyEndAllowThreads(__tstate);
36407 if (PyErr_Occurred()) SWIG_fail;
36408 }
36409 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36410 return resultobj;
36411 fail:
36412 return NULL;
36413 }
36414
36415
36416 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36417 PyObject *resultobj = 0;
36418 wxWindow *arg1 = (wxWindow *) 0 ;
36419 wxPoint *arg2 = 0 ;
36420 wxPoint result;
36421 void *argp1 = 0 ;
36422 int res1 = 0 ;
36423 wxPoint temp2 ;
36424 PyObject * obj0 = 0 ;
36425 PyObject * obj1 = 0 ;
36426 char * kwnames[] = {
36427 (char *) "self",(char *) "pt", NULL
36428 };
36429
36430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36432 if (!SWIG_IsOK(res1)) {
36433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36434 }
36435 arg1 = reinterpret_cast< wxWindow * >(argp1);
36436 {
36437 arg2 = &temp2;
36438 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36439 }
36440 {
36441 PyThreadState* __tstate = wxPyBeginAllowThreads();
36442 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36443 wxPyEndAllowThreads(__tstate);
36444 if (PyErr_Occurred()) SWIG_fail;
36445 }
36446 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36447 return resultobj;
36448 fail:
36449 return NULL;
36450 }
36451
36452
36453 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36454 PyObject *resultobj = 0;
36455 wxWindow *arg1 = (wxWindow *) 0 ;
36456 int arg2 ;
36457 int arg3 ;
36458 wxHitTest result;
36459 void *argp1 = 0 ;
36460 int res1 = 0 ;
36461 int val2 ;
36462 int ecode2 = 0 ;
36463 int val3 ;
36464 int ecode3 = 0 ;
36465 PyObject * obj0 = 0 ;
36466 PyObject * obj1 = 0 ;
36467 PyObject * obj2 = 0 ;
36468 char * kwnames[] = {
36469 (char *) "self",(char *) "x",(char *) "y", NULL
36470 };
36471
36472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36474 if (!SWIG_IsOK(res1)) {
36475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36476 }
36477 arg1 = reinterpret_cast< wxWindow * >(argp1);
36478 ecode2 = SWIG_AsVal_int(obj1, &val2);
36479 if (!SWIG_IsOK(ecode2)) {
36480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36481 }
36482 arg2 = static_cast< int >(val2);
36483 ecode3 = SWIG_AsVal_int(obj2, &val3);
36484 if (!SWIG_IsOK(ecode3)) {
36485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36486 }
36487 arg3 = static_cast< int >(val3);
36488 {
36489 PyThreadState* __tstate = wxPyBeginAllowThreads();
36490 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36491 wxPyEndAllowThreads(__tstate);
36492 if (PyErr_Occurred()) SWIG_fail;
36493 }
36494 resultobj = SWIG_From_int(static_cast< int >(result));
36495 return resultobj;
36496 fail:
36497 return NULL;
36498 }
36499
36500
36501 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36502 PyObject *resultobj = 0;
36503 wxWindow *arg1 = (wxWindow *) 0 ;
36504 wxPoint *arg2 = 0 ;
36505 wxHitTest result;
36506 void *argp1 = 0 ;
36507 int res1 = 0 ;
36508 wxPoint temp2 ;
36509 PyObject * obj0 = 0 ;
36510 PyObject * obj1 = 0 ;
36511 char * kwnames[] = {
36512 (char *) "self",(char *) "pt", NULL
36513 };
36514
36515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36517 if (!SWIG_IsOK(res1)) {
36518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36519 }
36520 arg1 = reinterpret_cast< wxWindow * >(argp1);
36521 {
36522 arg2 = &temp2;
36523 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36524 }
36525 {
36526 PyThreadState* __tstate = wxPyBeginAllowThreads();
36527 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36528 wxPyEndAllowThreads(__tstate);
36529 if (PyErr_Occurred()) SWIG_fail;
36530 }
36531 resultobj = SWIG_From_int(static_cast< int >(result));
36532 return resultobj;
36533 fail:
36534 return NULL;
36535 }
36536
36537
36538 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36539 PyObject *resultobj = 0;
36540 wxWindow *arg1 = (wxWindow *) 0 ;
36541 long arg2 ;
36542 wxBorder result;
36543 void *argp1 = 0 ;
36544 int res1 = 0 ;
36545 long val2 ;
36546 int ecode2 = 0 ;
36547
36548 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36550 if (!SWIG_IsOK(res1)) {
36551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36552 }
36553 arg1 = reinterpret_cast< wxWindow * >(argp1);
36554 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36555 if (!SWIG_IsOK(ecode2)) {
36556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36557 }
36558 arg2 = static_cast< long >(val2);
36559 {
36560 PyThreadState* __tstate = wxPyBeginAllowThreads();
36561 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36562 wxPyEndAllowThreads(__tstate);
36563 if (PyErr_Occurred()) SWIG_fail;
36564 }
36565 resultobj = SWIG_From_int(static_cast< int >(result));
36566 return resultobj;
36567 fail:
36568 return NULL;
36569 }
36570
36571
36572 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36573 PyObject *resultobj = 0;
36574 wxWindow *arg1 = (wxWindow *) 0 ;
36575 wxBorder result;
36576 void *argp1 = 0 ;
36577 int res1 = 0 ;
36578
36579 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36581 if (!SWIG_IsOK(res1)) {
36582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36583 }
36584 arg1 = reinterpret_cast< wxWindow * >(argp1);
36585 {
36586 PyThreadState* __tstate = wxPyBeginAllowThreads();
36587 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36588 wxPyEndAllowThreads(__tstate);
36589 if (PyErr_Occurred()) SWIG_fail;
36590 }
36591 resultobj = SWIG_From_int(static_cast< int >(result));
36592 return resultobj;
36593 fail:
36594 return NULL;
36595 }
36596
36597
36598 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36599 int argc;
36600 PyObject *argv[3];
36601
36602 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36603 --argc;
36604 if (argc == 1) {
36605 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36606 }
36607 if (argc == 2) {
36608 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36609 }
36610
36611 fail:
36612 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36613 return NULL;
36614 }
36615
36616
36617 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36618 PyObject *resultobj = 0;
36619 wxWindow *arg1 = (wxWindow *) 0 ;
36620 long arg2 = (long) wxUPDATE_UI_NONE ;
36621 void *argp1 = 0 ;
36622 int res1 = 0 ;
36623 long val2 ;
36624 int ecode2 = 0 ;
36625 PyObject * obj0 = 0 ;
36626 PyObject * obj1 = 0 ;
36627 char * kwnames[] = {
36628 (char *) "self",(char *) "flags", NULL
36629 };
36630
36631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36633 if (!SWIG_IsOK(res1)) {
36634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36635 }
36636 arg1 = reinterpret_cast< wxWindow * >(argp1);
36637 if (obj1) {
36638 ecode2 = SWIG_AsVal_long(obj1, &val2);
36639 if (!SWIG_IsOK(ecode2)) {
36640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36641 }
36642 arg2 = static_cast< long >(val2);
36643 }
36644 {
36645 PyThreadState* __tstate = wxPyBeginAllowThreads();
36646 (arg1)->UpdateWindowUI(arg2);
36647 wxPyEndAllowThreads(__tstate);
36648 if (PyErr_Occurred()) SWIG_fail;
36649 }
36650 resultobj = SWIG_Py_Void();
36651 return resultobj;
36652 fail:
36653 return NULL;
36654 }
36655
36656
36657 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36658 PyObject *resultobj = 0;
36659 wxWindow *arg1 = (wxWindow *) 0 ;
36660 wxMenu *arg2 = (wxMenu *) 0 ;
36661 int arg3 = (int) -1 ;
36662 int arg4 = (int) -1 ;
36663 bool result;
36664 void *argp1 = 0 ;
36665 int res1 = 0 ;
36666 void *argp2 = 0 ;
36667 int res2 = 0 ;
36668 int val3 ;
36669 int ecode3 = 0 ;
36670 int val4 ;
36671 int ecode4 = 0 ;
36672 PyObject * obj0 = 0 ;
36673 PyObject * obj1 = 0 ;
36674 PyObject * obj2 = 0 ;
36675 PyObject * obj3 = 0 ;
36676 char * kwnames[] = {
36677 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36678 };
36679
36680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36682 if (!SWIG_IsOK(res1)) {
36683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36684 }
36685 arg1 = reinterpret_cast< wxWindow * >(argp1);
36686 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36687 if (!SWIG_IsOK(res2)) {
36688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36689 }
36690 arg2 = reinterpret_cast< wxMenu * >(argp2);
36691 if (obj2) {
36692 ecode3 = SWIG_AsVal_int(obj2, &val3);
36693 if (!SWIG_IsOK(ecode3)) {
36694 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36695 }
36696 arg3 = static_cast< int >(val3);
36697 }
36698 if (obj3) {
36699 ecode4 = SWIG_AsVal_int(obj3, &val4);
36700 if (!SWIG_IsOK(ecode4)) {
36701 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36702 }
36703 arg4 = static_cast< int >(val4);
36704 }
36705 {
36706 PyThreadState* __tstate = wxPyBeginAllowThreads();
36707 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36708 wxPyEndAllowThreads(__tstate);
36709 if (PyErr_Occurred()) SWIG_fail;
36710 }
36711 {
36712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36713 }
36714 return resultobj;
36715 fail:
36716 return NULL;
36717 }
36718
36719
36720 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36721 PyObject *resultobj = 0;
36722 wxWindow *arg1 = (wxWindow *) 0 ;
36723 wxMenu *arg2 = (wxMenu *) 0 ;
36724 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36725 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36726 bool result;
36727 void *argp1 = 0 ;
36728 int res1 = 0 ;
36729 void *argp2 = 0 ;
36730 int res2 = 0 ;
36731 wxPoint temp3 ;
36732 PyObject * obj0 = 0 ;
36733 PyObject * obj1 = 0 ;
36734 PyObject * obj2 = 0 ;
36735 char * kwnames[] = {
36736 (char *) "self",(char *) "menu",(char *) "pos", NULL
36737 };
36738
36739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36741 if (!SWIG_IsOK(res1)) {
36742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36743 }
36744 arg1 = reinterpret_cast< wxWindow * >(argp1);
36745 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36746 if (!SWIG_IsOK(res2)) {
36747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36748 }
36749 arg2 = reinterpret_cast< wxMenu * >(argp2);
36750 if (obj2) {
36751 {
36752 arg3 = &temp3;
36753 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36754 }
36755 }
36756 {
36757 PyThreadState* __tstate = wxPyBeginAllowThreads();
36758 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36759 wxPyEndAllowThreads(__tstate);
36760 if (PyErr_Occurred()) SWIG_fail;
36761 }
36762 {
36763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36764 }
36765 return resultobj;
36766 fail:
36767 return NULL;
36768 }
36769
36770
36771 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36772 PyObject *resultobj = 0;
36773 wxWindow *arg1 = (wxWindow *) 0 ;
36774 bool result;
36775 void *argp1 = 0 ;
36776 int res1 = 0 ;
36777 PyObject *swig_obj[1] ;
36778
36779 if (!args) SWIG_fail;
36780 swig_obj[0] = args;
36781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36782 if (!SWIG_IsOK(res1)) {
36783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36784 }
36785 arg1 = reinterpret_cast< wxWindow * >(argp1);
36786 {
36787 PyThreadState* __tstate = wxPyBeginAllowThreads();
36788 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36789 wxPyEndAllowThreads(__tstate);
36790 if (PyErr_Occurred()) SWIG_fail;
36791 }
36792 {
36793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36794 }
36795 return resultobj;
36796 fail:
36797 return NULL;
36798 }
36799
36800
36801 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36802 PyObject *resultobj = 0;
36803 wxWindow *arg1 = (wxWindow *) 0 ;
36804 long result;
36805 void *argp1 = 0 ;
36806 int res1 = 0 ;
36807 PyObject *swig_obj[1] ;
36808
36809 if (!args) SWIG_fail;
36810 swig_obj[0] = args;
36811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36812 if (!SWIG_IsOK(res1)) {
36813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36814 }
36815 arg1 = reinterpret_cast< wxWindow * >(argp1);
36816 {
36817 PyThreadState* __tstate = wxPyBeginAllowThreads();
36818 result = (long)wxWindow_GetHandle(arg1);
36819 wxPyEndAllowThreads(__tstate);
36820 if (PyErr_Occurred()) SWIG_fail;
36821 }
36822 resultobj = SWIG_From_long(static_cast< long >(result));
36823 return resultobj;
36824 fail:
36825 return NULL;
36826 }
36827
36828
36829 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36830 PyObject *resultobj = 0;
36831 wxWindow *arg1 = (wxWindow *) 0 ;
36832 long arg2 ;
36833 void *argp1 = 0 ;
36834 int res1 = 0 ;
36835 long val2 ;
36836 int ecode2 = 0 ;
36837 PyObject * obj0 = 0 ;
36838 PyObject * obj1 = 0 ;
36839 char * kwnames[] = {
36840 (char *) "self",(char *) "handle", NULL
36841 };
36842
36843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36845 if (!SWIG_IsOK(res1)) {
36846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36847 }
36848 arg1 = reinterpret_cast< wxWindow * >(argp1);
36849 ecode2 = SWIG_AsVal_long(obj1, &val2);
36850 if (!SWIG_IsOK(ecode2)) {
36851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36852 }
36853 arg2 = static_cast< long >(val2);
36854 {
36855 PyThreadState* __tstate = wxPyBeginAllowThreads();
36856 wxWindow_AssociateHandle(arg1,arg2);
36857 wxPyEndAllowThreads(__tstate);
36858 if (PyErr_Occurred()) SWIG_fail;
36859 }
36860 resultobj = SWIG_Py_Void();
36861 return resultobj;
36862 fail:
36863 return NULL;
36864 }
36865
36866
36867 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36868 PyObject *resultobj = 0;
36869 wxWindow *arg1 = (wxWindow *) 0 ;
36870 void *argp1 = 0 ;
36871 int res1 = 0 ;
36872 PyObject *swig_obj[1] ;
36873
36874 if (!args) SWIG_fail;
36875 swig_obj[0] = args;
36876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36877 if (!SWIG_IsOK(res1)) {
36878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36879 }
36880 arg1 = reinterpret_cast< wxWindow * >(argp1);
36881 {
36882 PyThreadState* __tstate = wxPyBeginAllowThreads();
36883 (arg1)->DissociateHandle();
36884 wxPyEndAllowThreads(__tstate);
36885 if (PyErr_Occurred()) SWIG_fail;
36886 }
36887 resultobj = SWIG_Py_Void();
36888 return resultobj;
36889 fail:
36890 return NULL;
36891 }
36892
36893
36894 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36895 PyObject *resultobj = 0;
36896 wxWindow *arg1 = (wxWindow *) 0 ;
36897 wxPaintEvent *arg2 = 0 ;
36898 void *argp1 = 0 ;
36899 int res1 = 0 ;
36900 void *argp2 = 0 ;
36901 int res2 = 0 ;
36902 PyObject * obj0 = 0 ;
36903 PyObject * obj1 = 0 ;
36904 char * kwnames[] = {
36905 (char *) "self",(char *) "event", NULL
36906 };
36907
36908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36910 if (!SWIG_IsOK(res1)) {
36911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36912 }
36913 arg1 = reinterpret_cast< wxWindow * >(argp1);
36914 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36915 if (!SWIG_IsOK(res2)) {
36916 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36917 }
36918 if (!argp2) {
36919 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36920 }
36921 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36922 {
36923 PyThreadState* __tstate = wxPyBeginAllowThreads();
36924 (arg1)->OnPaint(*arg2);
36925 wxPyEndAllowThreads(__tstate);
36926 if (PyErr_Occurred()) SWIG_fail;
36927 }
36928 resultobj = SWIG_Py_Void();
36929 return resultobj;
36930 fail:
36931 return NULL;
36932 }
36933
36934
36935 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36936 PyObject *resultobj = 0;
36937 wxWindow *arg1 = (wxWindow *) 0 ;
36938 int arg2 ;
36939 bool result;
36940 void *argp1 = 0 ;
36941 int res1 = 0 ;
36942 int val2 ;
36943 int ecode2 = 0 ;
36944 PyObject * obj0 = 0 ;
36945 PyObject * obj1 = 0 ;
36946 char * kwnames[] = {
36947 (char *) "self",(char *) "orient", NULL
36948 };
36949
36950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36952 if (!SWIG_IsOK(res1)) {
36953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36954 }
36955 arg1 = reinterpret_cast< wxWindow * >(argp1);
36956 ecode2 = SWIG_AsVal_int(obj1, &val2);
36957 if (!SWIG_IsOK(ecode2)) {
36958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36959 }
36960 arg2 = static_cast< int >(val2);
36961 {
36962 PyThreadState* __tstate = wxPyBeginAllowThreads();
36963 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36964 wxPyEndAllowThreads(__tstate);
36965 if (PyErr_Occurred()) SWIG_fail;
36966 }
36967 {
36968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36969 }
36970 return resultobj;
36971 fail:
36972 return NULL;
36973 }
36974
36975
36976 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36977 PyObject *resultobj = 0;
36978 wxWindow *arg1 = (wxWindow *) 0 ;
36979 int arg2 ;
36980 int arg3 ;
36981 int arg4 ;
36982 int arg5 ;
36983 bool arg6 = (bool) true ;
36984 void *argp1 = 0 ;
36985 int res1 = 0 ;
36986 int val2 ;
36987 int ecode2 = 0 ;
36988 int val3 ;
36989 int ecode3 = 0 ;
36990 int val4 ;
36991 int ecode4 = 0 ;
36992 int val5 ;
36993 int ecode5 = 0 ;
36994 bool val6 ;
36995 int ecode6 = 0 ;
36996 PyObject * obj0 = 0 ;
36997 PyObject * obj1 = 0 ;
36998 PyObject * obj2 = 0 ;
36999 PyObject * obj3 = 0 ;
37000 PyObject * obj4 = 0 ;
37001 PyObject * obj5 = 0 ;
37002 char * kwnames[] = {
37003 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
37004 };
37005
37006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37008 if (!SWIG_IsOK(res1)) {
37009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
37010 }
37011 arg1 = reinterpret_cast< wxWindow * >(argp1);
37012 ecode2 = SWIG_AsVal_int(obj1, &val2);
37013 if (!SWIG_IsOK(ecode2)) {
37014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
37015 }
37016 arg2 = static_cast< int >(val2);
37017 ecode3 = SWIG_AsVal_int(obj2, &val3);
37018 if (!SWIG_IsOK(ecode3)) {
37019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37020 }
37021 arg3 = static_cast< int >(val3);
37022 ecode4 = SWIG_AsVal_int(obj3, &val4);
37023 if (!SWIG_IsOK(ecode4)) {
37024 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37025 }
37026 arg4 = static_cast< int >(val4);
37027 ecode5 = SWIG_AsVal_int(obj4, &val5);
37028 if (!SWIG_IsOK(ecode5)) {
37029 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37030 }
37031 arg5 = static_cast< int >(val5);
37032 if (obj5) {
37033 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37034 if (!SWIG_IsOK(ecode6)) {
37035 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37036 }
37037 arg6 = static_cast< bool >(val6);
37038 }
37039 {
37040 PyThreadState* __tstate = wxPyBeginAllowThreads();
37041 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37042 wxPyEndAllowThreads(__tstate);
37043 if (PyErr_Occurred()) SWIG_fail;
37044 }
37045 resultobj = SWIG_Py_Void();
37046 return resultobj;
37047 fail:
37048 return NULL;
37049 }
37050
37051
37052 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37053 PyObject *resultobj = 0;
37054 wxWindow *arg1 = (wxWindow *) 0 ;
37055 int arg2 ;
37056 int arg3 ;
37057 bool arg4 = (bool) true ;
37058 void *argp1 = 0 ;
37059 int res1 = 0 ;
37060 int val2 ;
37061 int ecode2 = 0 ;
37062 int val3 ;
37063 int ecode3 = 0 ;
37064 bool val4 ;
37065 int ecode4 = 0 ;
37066 PyObject * obj0 = 0 ;
37067 PyObject * obj1 = 0 ;
37068 PyObject * obj2 = 0 ;
37069 PyObject * obj3 = 0 ;
37070 char * kwnames[] = {
37071 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37072 };
37073
37074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37076 if (!SWIG_IsOK(res1)) {
37077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37078 }
37079 arg1 = reinterpret_cast< wxWindow * >(argp1);
37080 ecode2 = SWIG_AsVal_int(obj1, &val2);
37081 if (!SWIG_IsOK(ecode2)) {
37082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37083 }
37084 arg2 = static_cast< int >(val2);
37085 ecode3 = SWIG_AsVal_int(obj2, &val3);
37086 if (!SWIG_IsOK(ecode3)) {
37087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37088 }
37089 arg3 = static_cast< int >(val3);
37090 if (obj3) {
37091 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37092 if (!SWIG_IsOK(ecode4)) {
37093 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37094 }
37095 arg4 = static_cast< bool >(val4);
37096 }
37097 {
37098 PyThreadState* __tstate = wxPyBeginAllowThreads();
37099 (arg1)->SetScrollPos(arg2,arg3,arg4);
37100 wxPyEndAllowThreads(__tstate);
37101 if (PyErr_Occurred()) SWIG_fail;
37102 }
37103 resultobj = SWIG_Py_Void();
37104 return resultobj;
37105 fail:
37106 return NULL;
37107 }
37108
37109
37110 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37111 PyObject *resultobj = 0;
37112 wxWindow *arg1 = (wxWindow *) 0 ;
37113 int arg2 ;
37114 int result;
37115 void *argp1 = 0 ;
37116 int res1 = 0 ;
37117 int val2 ;
37118 int ecode2 = 0 ;
37119 PyObject * obj0 = 0 ;
37120 PyObject * obj1 = 0 ;
37121 char * kwnames[] = {
37122 (char *) "self",(char *) "orientation", NULL
37123 };
37124
37125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37127 if (!SWIG_IsOK(res1)) {
37128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37129 }
37130 arg1 = reinterpret_cast< wxWindow * >(argp1);
37131 ecode2 = SWIG_AsVal_int(obj1, &val2);
37132 if (!SWIG_IsOK(ecode2)) {
37133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37134 }
37135 arg2 = static_cast< int >(val2);
37136 {
37137 PyThreadState* __tstate = wxPyBeginAllowThreads();
37138 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37139 wxPyEndAllowThreads(__tstate);
37140 if (PyErr_Occurred()) SWIG_fail;
37141 }
37142 resultobj = SWIG_From_int(static_cast< int >(result));
37143 return resultobj;
37144 fail:
37145 return NULL;
37146 }
37147
37148
37149 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37150 PyObject *resultobj = 0;
37151 wxWindow *arg1 = (wxWindow *) 0 ;
37152 int arg2 ;
37153 int result;
37154 void *argp1 = 0 ;
37155 int res1 = 0 ;
37156 int val2 ;
37157 int ecode2 = 0 ;
37158 PyObject * obj0 = 0 ;
37159 PyObject * obj1 = 0 ;
37160 char * kwnames[] = {
37161 (char *) "self",(char *) "orientation", NULL
37162 };
37163
37164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37166 if (!SWIG_IsOK(res1)) {
37167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37168 }
37169 arg1 = reinterpret_cast< wxWindow * >(argp1);
37170 ecode2 = SWIG_AsVal_int(obj1, &val2);
37171 if (!SWIG_IsOK(ecode2)) {
37172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37173 }
37174 arg2 = static_cast< int >(val2);
37175 {
37176 PyThreadState* __tstate = wxPyBeginAllowThreads();
37177 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37178 wxPyEndAllowThreads(__tstate);
37179 if (PyErr_Occurred()) SWIG_fail;
37180 }
37181 resultobj = SWIG_From_int(static_cast< int >(result));
37182 return resultobj;
37183 fail:
37184 return NULL;
37185 }
37186
37187
37188 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37189 PyObject *resultobj = 0;
37190 wxWindow *arg1 = (wxWindow *) 0 ;
37191 int arg2 ;
37192 int result;
37193 void *argp1 = 0 ;
37194 int res1 = 0 ;
37195 int val2 ;
37196 int ecode2 = 0 ;
37197 PyObject * obj0 = 0 ;
37198 PyObject * obj1 = 0 ;
37199 char * kwnames[] = {
37200 (char *) "self",(char *) "orientation", NULL
37201 };
37202
37203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37205 if (!SWIG_IsOK(res1)) {
37206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37207 }
37208 arg1 = reinterpret_cast< wxWindow * >(argp1);
37209 ecode2 = SWIG_AsVal_int(obj1, &val2);
37210 if (!SWIG_IsOK(ecode2)) {
37211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37212 }
37213 arg2 = static_cast< int >(val2);
37214 {
37215 PyThreadState* __tstate = wxPyBeginAllowThreads();
37216 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37217 wxPyEndAllowThreads(__tstate);
37218 if (PyErr_Occurred()) SWIG_fail;
37219 }
37220 resultobj = SWIG_From_int(static_cast< int >(result));
37221 return resultobj;
37222 fail:
37223 return NULL;
37224 }
37225
37226
37227 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37228 PyObject *resultobj = 0;
37229 wxWindow *arg1 = (wxWindow *) 0 ;
37230 int arg2 ;
37231 int arg3 ;
37232 wxRect *arg4 = (wxRect *) NULL ;
37233 void *argp1 = 0 ;
37234 int res1 = 0 ;
37235 int val2 ;
37236 int ecode2 = 0 ;
37237 int val3 ;
37238 int ecode3 = 0 ;
37239 void *argp4 = 0 ;
37240 int res4 = 0 ;
37241 PyObject * obj0 = 0 ;
37242 PyObject * obj1 = 0 ;
37243 PyObject * obj2 = 0 ;
37244 PyObject * obj3 = 0 ;
37245 char * kwnames[] = {
37246 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37247 };
37248
37249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37251 if (!SWIG_IsOK(res1)) {
37252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37253 }
37254 arg1 = reinterpret_cast< wxWindow * >(argp1);
37255 ecode2 = SWIG_AsVal_int(obj1, &val2);
37256 if (!SWIG_IsOK(ecode2)) {
37257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37258 }
37259 arg2 = static_cast< int >(val2);
37260 ecode3 = SWIG_AsVal_int(obj2, &val3);
37261 if (!SWIG_IsOK(ecode3)) {
37262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37263 }
37264 arg3 = static_cast< int >(val3);
37265 if (obj3) {
37266 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37267 if (!SWIG_IsOK(res4)) {
37268 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37269 }
37270 arg4 = reinterpret_cast< wxRect * >(argp4);
37271 }
37272 {
37273 PyThreadState* __tstate = wxPyBeginAllowThreads();
37274 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37275 wxPyEndAllowThreads(__tstate);
37276 if (PyErr_Occurred()) SWIG_fail;
37277 }
37278 resultobj = SWIG_Py_Void();
37279 return resultobj;
37280 fail:
37281 return NULL;
37282 }
37283
37284
37285 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37286 PyObject *resultobj = 0;
37287 wxWindow *arg1 = (wxWindow *) 0 ;
37288 int arg2 ;
37289 bool result;
37290 void *argp1 = 0 ;
37291 int res1 = 0 ;
37292 int val2 ;
37293 int ecode2 = 0 ;
37294 PyObject * obj0 = 0 ;
37295 PyObject * obj1 = 0 ;
37296 char * kwnames[] = {
37297 (char *) "self",(char *) "lines", NULL
37298 };
37299
37300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37302 if (!SWIG_IsOK(res1)) {
37303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37304 }
37305 arg1 = reinterpret_cast< wxWindow * >(argp1);
37306 ecode2 = SWIG_AsVal_int(obj1, &val2);
37307 if (!SWIG_IsOK(ecode2)) {
37308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37309 }
37310 arg2 = static_cast< int >(val2);
37311 {
37312 PyThreadState* __tstate = wxPyBeginAllowThreads();
37313 result = (bool)(arg1)->ScrollLines(arg2);
37314 wxPyEndAllowThreads(__tstate);
37315 if (PyErr_Occurred()) SWIG_fail;
37316 }
37317 {
37318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37319 }
37320 return resultobj;
37321 fail:
37322 return NULL;
37323 }
37324
37325
37326 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37327 PyObject *resultobj = 0;
37328 wxWindow *arg1 = (wxWindow *) 0 ;
37329 int arg2 ;
37330 bool result;
37331 void *argp1 = 0 ;
37332 int res1 = 0 ;
37333 int val2 ;
37334 int ecode2 = 0 ;
37335 PyObject * obj0 = 0 ;
37336 PyObject * obj1 = 0 ;
37337 char * kwnames[] = {
37338 (char *) "self",(char *) "pages", NULL
37339 };
37340
37341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37343 if (!SWIG_IsOK(res1)) {
37344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37345 }
37346 arg1 = reinterpret_cast< wxWindow * >(argp1);
37347 ecode2 = SWIG_AsVal_int(obj1, &val2);
37348 if (!SWIG_IsOK(ecode2)) {
37349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37350 }
37351 arg2 = static_cast< int >(val2);
37352 {
37353 PyThreadState* __tstate = wxPyBeginAllowThreads();
37354 result = (bool)(arg1)->ScrollPages(arg2);
37355 wxPyEndAllowThreads(__tstate);
37356 if (PyErr_Occurred()) SWIG_fail;
37357 }
37358 {
37359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37360 }
37361 return resultobj;
37362 fail:
37363 return NULL;
37364 }
37365
37366
37367 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37368 PyObject *resultobj = 0;
37369 wxWindow *arg1 = (wxWindow *) 0 ;
37370 bool result;
37371 void *argp1 = 0 ;
37372 int res1 = 0 ;
37373 PyObject *swig_obj[1] ;
37374
37375 if (!args) SWIG_fail;
37376 swig_obj[0] = args;
37377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37378 if (!SWIG_IsOK(res1)) {
37379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37380 }
37381 arg1 = reinterpret_cast< wxWindow * >(argp1);
37382 {
37383 PyThreadState* __tstate = wxPyBeginAllowThreads();
37384 result = (bool)(arg1)->LineUp();
37385 wxPyEndAllowThreads(__tstate);
37386 if (PyErr_Occurred()) SWIG_fail;
37387 }
37388 {
37389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37390 }
37391 return resultobj;
37392 fail:
37393 return NULL;
37394 }
37395
37396
37397 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37398 PyObject *resultobj = 0;
37399 wxWindow *arg1 = (wxWindow *) 0 ;
37400 bool result;
37401 void *argp1 = 0 ;
37402 int res1 = 0 ;
37403 PyObject *swig_obj[1] ;
37404
37405 if (!args) SWIG_fail;
37406 swig_obj[0] = args;
37407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37408 if (!SWIG_IsOK(res1)) {
37409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37410 }
37411 arg1 = reinterpret_cast< wxWindow * >(argp1);
37412 {
37413 PyThreadState* __tstate = wxPyBeginAllowThreads();
37414 result = (bool)(arg1)->LineDown();
37415 wxPyEndAllowThreads(__tstate);
37416 if (PyErr_Occurred()) SWIG_fail;
37417 }
37418 {
37419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37420 }
37421 return resultobj;
37422 fail:
37423 return NULL;
37424 }
37425
37426
37427 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37428 PyObject *resultobj = 0;
37429 wxWindow *arg1 = (wxWindow *) 0 ;
37430 bool result;
37431 void *argp1 = 0 ;
37432 int res1 = 0 ;
37433 PyObject *swig_obj[1] ;
37434
37435 if (!args) SWIG_fail;
37436 swig_obj[0] = args;
37437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37438 if (!SWIG_IsOK(res1)) {
37439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37440 }
37441 arg1 = reinterpret_cast< wxWindow * >(argp1);
37442 {
37443 PyThreadState* __tstate = wxPyBeginAllowThreads();
37444 result = (bool)(arg1)->PageUp();
37445 wxPyEndAllowThreads(__tstate);
37446 if (PyErr_Occurred()) SWIG_fail;
37447 }
37448 {
37449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37450 }
37451 return resultobj;
37452 fail:
37453 return NULL;
37454 }
37455
37456
37457 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37458 PyObject *resultobj = 0;
37459 wxWindow *arg1 = (wxWindow *) 0 ;
37460 bool result;
37461 void *argp1 = 0 ;
37462 int res1 = 0 ;
37463 PyObject *swig_obj[1] ;
37464
37465 if (!args) SWIG_fail;
37466 swig_obj[0] = args;
37467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37468 if (!SWIG_IsOK(res1)) {
37469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37470 }
37471 arg1 = reinterpret_cast< wxWindow * >(argp1);
37472 {
37473 PyThreadState* __tstate = wxPyBeginAllowThreads();
37474 result = (bool)(arg1)->PageDown();
37475 wxPyEndAllowThreads(__tstate);
37476 if (PyErr_Occurred()) SWIG_fail;
37477 }
37478 {
37479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37480 }
37481 return resultobj;
37482 fail:
37483 return NULL;
37484 }
37485
37486
37487 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37488 PyObject *resultobj = 0;
37489 wxWindow *arg1 = (wxWindow *) 0 ;
37490 wxString *arg2 = 0 ;
37491 void *argp1 = 0 ;
37492 int res1 = 0 ;
37493 bool temp2 = false ;
37494 PyObject * obj0 = 0 ;
37495 PyObject * obj1 = 0 ;
37496 char * kwnames[] = {
37497 (char *) "self",(char *) "text", NULL
37498 };
37499
37500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37502 if (!SWIG_IsOK(res1)) {
37503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37504 }
37505 arg1 = reinterpret_cast< wxWindow * >(argp1);
37506 {
37507 arg2 = wxString_in_helper(obj1);
37508 if (arg2 == NULL) SWIG_fail;
37509 temp2 = true;
37510 }
37511 {
37512 PyThreadState* __tstate = wxPyBeginAllowThreads();
37513 (arg1)->SetHelpText((wxString const &)*arg2);
37514 wxPyEndAllowThreads(__tstate);
37515 if (PyErr_Occurred()) SWIG_fail;
37516 }
37517 resultobj = SWIG_Py_Void();
37518 {
37519 if (temp2)
37520 delete arg2;
37521 }
37522 return resultobj;
37523 fail:
37524 {
37525 if (temp2)
37526 delete arg2;
37527 }
37528 return NULL;
37529 }
37530
37531
37532 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37533 PyObject *resultobj = 0;
37534 wxWindow *arg1 = (wxWindow *) 0 ;
37535 wxString *arg2 = 0 ;
37536 void *argp1 = 0 ;
37537 int res1 = 0 ;
37538 bool temp2 = false ;
37539 PyObject * obj0 = 0 ;
37540 PyObject * obj1 = 0 ;
37541 char * kwnames[] = {
37542 (char *) "self",(char *) "text", NULL
37543 };
37544
37545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37547 if (!SWIG_IsOK(res1)) {
37548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37549 }
37550 arg1 = reinterpret_cast< wxWindow * >(argp1);
37551 {
37552 arg2 = wxString_in_helper(obj1);
37553 if (arg2 == NULL) SWIG_fail;
37554 temp2 = true;
37555 }
37556 {
37557 PyThreadState* __tstate = wxPyBeginAllowThreads();
37558 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37559 wxPyEndAllowThreads(__tstate);
37560 if (PyErr_Occurred()) SWIG_fail;
37561 }
37562 resultobj = SWIG_Py_Void();
37563 {
37564 if (temp2)
37565 delete arg2;
37566 }
37567 return resultobj;
37568 fail:
37569 {
37570 if (temp2)
37571 delete arg2;
37572 }
37573 return NULL;
37574 }
37575
37576
37577 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37578 PyObject *resultobj = 0;
37579 wxWindow *arg1 = (wxWindow *) 0 ;
37580 wxPoint *arg2 = 0 ;
37581 wxHelpEvent::Origin arg3 ;
37582 wxString result;
37583 void *argp1 = 0 ;
37584 int res1 = 0 ;
37585 wxPoint temp2 ;
37586 void *argp3 ;
37587 int res3 = 0 ;
37588 PyObject * obj0 = 0 ;
37589 PyObject * obj1 = 0 ;
37590 PyObject * obj2 = 0 ;
37591 char * kwnames[] = {
37592 (char *) "self",(char *) "pt",(char *) "origin", NULL
37593 };
37594
37595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37597 if (!SWIG_IsOK(res1)) {
37598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37599 }
37600 arg1 = reinterpret_cast< wxWindow * >(argp1);
37601 {
37602 arg2 = &temp2;
37603 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37604 }
37605 {
37606 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37607 if (!SWIG_IsOK(res3)) {
37608 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37609 }
37610 if (!argp3) {
37611 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37612 } else {
37613 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37614 arg3 = *temp;
37615 if (SWIG_IsNewObj(res3)) delete temp;
37616 }
37617 }
37618 {
37619 PyThreadState* __tstate = wxPyBeginAllowThreads();
37620 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37621 wxPyEndAllowThreads(__tstate);
37622 if (PyErr_Occurred()) SWIG_fail;
37623 }
37624 {
37625 #if wxUSE_UNICODE
37626 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37627 #else
37628 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37629 #endif
37630 }
37631 return resultobj;
37632 fail:
37633 return NULL;
37634 }
37635
37636
37637 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37638 PyObject *resultobj = 0;
37639 wxWindow *arg1 = (wxWindow *) 0 ;
37640 wxString result;
37641 void *argp1 = 0 ;
37642 int res1 = 0 ;
37643 PyObject *swig_obj[1] ;
37644
37645 if (!args) SWIG_fail;
37646 swig_obj[0] = args;
37647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37648 if (!SWIG_IsOK(res1)) {
37649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37650 }
37651 arg1 = reinterpret_cast< wxWindow * >(argp1);
37652 {
37653 PyThreadState* __tstate = wxPyBeginAllowThreads();
37654 result = ((wxWindow const *)arg1)->GetHelpText();
37655 wxPyEndAllowThreads(__tstate);
37656 if (PyErr_Occurred()) SWIG_fail;
37657 }
37658 {
37659 #if wxUSE_UNICODE
37660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37661 #else
37662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37663 #endif
37664 }
37665 return resultobj;
37666 fail:
37667 return NULL;
37668 }
37669
37670
37671 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37672 PyObject *resultobj = 0;
37673 wxWindow *arg1 = (wxWindow *) 0 ;
37674 wxString *arg2 = 0 ;
37675 void *argp1 = 0 ;
37676 int res1 = 0 ;
37677 bool temp2 = false ;
37678 PyObject * obj0 = 0 ;
37679 PyObject * obj1 = 0 ;
37680 char * kwnames[] = {
37681 (char *) "self",(char *) "tip", NULL
37682 };
37683
37684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37686 if (!SWIG_IsOK(res1)) {
37687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37688 }
37689 arg1 = reinterpret_cast< wxWindow * >(argp1);
37690 {
37691 arg2 = wxString_in_helper(obj1);
37692 if (arg2 == NULL) SWIG_fail;
37693 temp2 = true;
37694 }
37695 {
37696 PyThreadState* __tstate = wxPyBeginAllowThreads();
37697 (arg1)->SetToolTip((wxString const &)*arg2);
37698 wxPyEndAllowThreads(__tstate);
37699 if (PyErr_Occurred()) SWIG_fail;
37700 }
37701 resultobj = SWIG_Py_Void();
37702 {
37703 if (temp2)
37704 delete arg2;
37705 }
37706 return resultobj;
37707 fail:
37708 {
37709 if (temp2)
37710 delete arg2;
37711 }
37712 return NULL;
37713 }
37714
37715
37716 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37717 PyObject *resultobj = 0;
37718 wxWindow *arg1 = (wxWindow *) 0 ;
37719 wxToolTip *arg2 = (wxToolTip *) 0 ;
37720 void *argp1 = 0 ;
37721 int res1 = 0 ;
37722 int res2 = 0 ;
37723 PyObject * obj0 = 0 ;
37724 PyObject * obj1 = 0 ;
37725 char * kwnames[] = {
37726 (char *) "self",(char *) "tip", NULL
37727 };
37728
37729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37731 if (!SWIG_IsOK(res1)) {
37732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37733 }
37734 arg1 = reinterpret_cast< wxWindow * >(argp1);
37735 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37736 if (!SWIG_IsOK(res2)) {
37737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37738 }
37739 {
37740 PyThreadState* __tstate = wxPyBeginAllowThreads();
37741 (arg1)->SetToolTip(arg2);
37742 wxPyEndAllowThreads(__tstate);
37743 if (PyErr_Occurred()) SWIG_fail;
37744 }
37745 resultobj = SWIG_Py_Void();
37746 return resultobj;
37747 fail:
37748 return NULL;
37749 }
37750
37751
37752 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37753 PyObject *resultobj = 0;
37754 wxWindow *arg1 = (wxWindow *) 0 ;
37755 wxToolTip *result = 0 ;
37756 void *argp1 = 0 ;
37757 int res1 = 0 ;
37758 PyObject *swig_obj[1] ;
37759
37760 if (!args) SWIG_fail;
37761 swig_obj[0] = args;
37762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37763 if (!SWIG_IsOK(res1)) {
37764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37765 }
37766 arg1 = reinterpret_cast< wxWindow * >(argp1);
37767 {
37768 PyThreadState* __tstate = wxPyBeginAllowThreads();
37769 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37770 wxPyEndAllowThreads(__tstate);
37771 if (PyErr_Occurred()) SWIG_fail;
37772 }
37773 {
37774 resultobj = wxPyMake_wxObject(result, (bool)0);
37775 }
37776 return resultobj;
37777 fail:
37778 return NULL;
37779 }
37780
37781
37782 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37783 PyObject *resultobj = 0;
37784 wxWindow *arg1 = (wxWindow *) 0 ;
37785 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37786 void *argp1 = 0 ;
37787 int res1 = 0 ;
37788 int res2 = 0 ;
37789 PyObject * obj0 = 0 ;
37790 PyObject * obj1 = 0 ;
37791 char * kwnames[] = {
37792 (char *) "self",(char *) "dropTarget", NULL
37793 };
37794
37795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37797 if (!SWIG_IsOK(res1)) {
37798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37799 }
37800 arg1 = reinterpret_cast< wxWindow * >(argp1);
37801 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37802 if (!SWIG_IsOK(res2)) {
37803 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37804 }
37805 {
37806 PyThreadState* __tstate = wxPyBeginAllowThreads();
37807 (arg1)->SetDropTarget(arg2);
37808 wxPyEndAllowThreads(__tstate);
37809 if (PyErr_Occurred()) SWIG_fail;
37810 }
37811 resultobj = SWIG_Py_Void();
37812 return resultobj;
37813 fail:
37814 return NULL;
37815 }
37816
37817
37818 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37819 PyObject *resultobj = 0;
37820 wxWindow *arg1 = (wxWindow *) 0 ;
37821 wxPyDropTarget *result = 0 ;
37822 void *argp1 = 0 ;
37823 int res1 = 0 ;
37824 PyObject *swig_obj[1] ;
37825
37826 if (!args) SWIG_fail;
37827 swig_obj[0] = args;
37828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37829 if (!SWIG_IsOK(res1)) {
37830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37831 }
37832 arg1 = reinterpret_cast< wxWindow * >(argp1);
37833 {
37834 PyThreadState* __tstate = wxPyBeginAllowThreads();
37835 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37836 wxPyEndAllowThreads(__tstate);
37837 if (PyErr_Occurred()) SWIG_fail;
37838 }
37839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37840 return resultobj;
37841 fail:
37842 return NULL;
37843 }
37844
37845
37846 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37847 PyObject *resultobj = 0;
37848 wxWindow *arg1 = (wxWindow *) 0 ;
37849 bool arg2 ;
37850 void *argp1 = 0 ;
37851 int res1 = 0 ;
37852 bool val2 ;
37853 int ecode2 = 0 ;
37854 PyObject * obj0 = 0 ;
37855 PyObject * obj1 = 0 ;
37856 char * kwnames[] = {
37857 (char *) "self",(char *) "accept", NULL
37858 };
37859
37860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37862 if (!SWIG_IsOK(res1)) {
37863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37864 }
37865 arg1 = reinterpret_cast< wxWindow * >(argp1);
37866 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37867 if (!SWIG_IsOK(ecode2)) {
37868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37869 }
37870 arg2 = static_cast< bool >(val2);
37871 {
37872 PyThreadState* __tstate = wxPyBeginAllowThreads();
37873 (arg1)->DragAcceptFiles(arg2);
37874 wxPyEndAllowThreads(__tstate);
37875 if (PyErr_Occurred()) SWIG_fail;
37876 }
37877 resultobj = SWIG_Py_Void();
37878 return resultobj;
37879 fail:
37880 return NULL;
37881 }
37882
37883
37884 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37885 PyObject *resultobj = 0;
37886 wxWindow *arg1 = (wxWindow *) 0 ;
37887 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37888 void *argp1 = 0 ;
37889 int res1 = 0 ;
37890 int res2 = 0 ;
37891 PyObject * obj0 = 0 ;
37892 PyObject * obj1 = 0 ;
37893 char * kwnames[] = {
37894 (char *) "self",(char *) "constraints", NULL
37895 };
37896
37897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37899 if (!SWIG_IsOK(res1)) {
37900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37901 }
37902 arg1 = reinterpret_cast< wxWindow * >(argp1);
37903 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37904 if (!SWIG_IsOK(res2)) {
37905 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37906 }
37907 {
37908 PyThreadState* __tstate = wxPyBeginAllowThreads();
37909 (arg1)->SetConstraints(arg2);
37910 wxPyEndAllowThreads(__tstate);
37911 if (PyErr_Occurred()) SWIG_fail;
37912 }
37913 resultobj = SWIG_Py_Void();
37914 return resultobj;
37915 fail:
37916 return NULL;
37917 }
37918
37919
37920 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37921 PyObject *resultobj = 0;
37922 wxWindow *arg1 = (wxWindow *) 0 ;
37923 wxLayoutConstraints *result = 0 ;
37924 void *argp1 = 0 ;
37925 int res1 = 0 ;
37926 PyObject *swig_obj[1] ;
37927
37928 if (!args) SWIG_fail;
37929 swig_obj[0] = args;
37930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37931 if (!SWIG_IsOK(res1)) {
37932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37933 }
37934 arg1 = reinterpret_cast< wxWindow * >(argp1);
37935 {
37936 PyThreadState* __tstate = wxPyBeginAllowThreads();
37937 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37938 wxPyEndAllowThreads(__tstate);
37939 if (PyErr_Occurred()) SWIG_fail;
37940 }
37941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37942 return resultobj;
37943 fail:
37944 return NULL;
37945 }
37946
37947
37948 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37949 PyObject *resultobj = 0;
37950 wxWindow *arg1 = (wxWindow *) 0 ;
37951 bool arg2 ;
37952 void *argp1 = 0 ;
37953 int res1 = 0 ;
37954 bool val2 ;
37955 int ecode2 = 0 ;
37956 PyObject * obj0 = 0 ;
37957 PyObject * obj1 = 0 ;
37958 char * kwnames[] = {
37959 (char *) "self",(char *) "autoLayout", NULL
37960 };
37961
37962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37964 if (!SWIG_IsOK(res1)) {
37965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37966 }
37967 arg1 = reinterpret_cast< wxWindow * >(argp1);
37968 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37969 if (!SWIG_IsOK(ecode2)) {
37970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37971 }
37972 arg2 = static_cast< bool >(val2);
37973 {
37974 PyThreadState* __tstate = wxPyBeginAllowThreads();
37975 (arg1)->SetAutoLayout(arg2);
37976 wxPyEndAllowThreads(__tstate);
37977 if (PyErr_Occurred()) SWIG_fail;
37978 }
37979 resultobj = SWIG_Py_Void();
37980 return resultobj;
37981 fail:
37982 return NULL;
37983 }
37984
37985
37986 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37987 PyObject *resultobj = 0;
37988 wxWindow *arg1 = (wxWindow *) 0 ;
37989 bool result;
37990 void *argp1 = 0 ;
37991 int res1 = 0 ;
37992 PyObject *swig_obj[1] ;
37993
37994 if (!args) SWIG_fail;
37995 swig_obj[0] = args;
37996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37997 if (!SWIG_IsOK(res1)) {
37998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37999 }
38000 arg1 = reinterpret_cast< wxWindow * >(argp1);
38001 {
38002 PyThreadState* __tstate = wxPyBeginAllowThreads();
38003 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
38004 wxPyEndAllowThreads(__tstate);
38005 if (PyErr_Occurred()) SWIG_fail;
38006 }
38007 {
38008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38009 }
38010 return resultobj;
38011 fail:
38012 return NULL;
38013 }
38014
38015
38016 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38017 PyObject *resultobj = 0;
38018 wxWindow *arg1 = (wxWindow *) 0 ;
38019 bool result;
38020 void *argp1 = 0 ;
38021 int res1 = 0 ;
38022 PyObject *swig_obj[1] ;
38023
38024 if (!args) SWIG_fail;
38025 swig_obj[0] = args;
38026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38027 if (!SWIG_IsOK(res1)) {
38028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38029 }
38030 arg1 = reinterpret_cast< wxWindow * >(argp1);
38031 {
38032 PyThreadState* __tstate = wxPyBeginAllowThreads();
38033 result = (bool)(arg1)->Layout();
38034 wxPyEndAllowThreads(__tstate);
38035 if (PyErr_Occurred()) SWIG_fail;
38036 }
38037 {
38038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38039 }
38040 return resultobj;
38041 fail:
38042 return NULL;
38043 }
38044
38045
38046 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38047 PyObject *resultobj = 0;
38048 wxWindow *arg1 = (wxWindow *) 0 ;
38049 wxSizer *arg2 = (wxSizer *) 0 ;
38050 bool arg3 = (bool) true ;
38051 void *argp1 = 0 ;
38052 int res1 = 0 ;
38053 int res2 = 0 ;
38054 bool val3 ;
38055 int ecode3 = 0 ;
38056 PyObject * obj0 = 0 ;
38057 PyObject * obj1 = 0 ;
38058 PyObject * obj2 = 0 ;
38059 char * kwnames[] = {
38060 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38061 };
38062
38063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38065 if (!SWIG_IsOK(res1)) {
38066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38067 }
38068 arg1 = reinterpret_cast< wxWindow * >(argp1);
38069 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38070 if (!SWIG_IsOK(res2)) {
38071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38072 }
38073 if (obj2) {
38074 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38075 if (!SWIG_IsOK(ecode3)) {
38076 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38077 }
38078 arg3 = static_cast< bool >(val3);
38079 }
38080 {
38081 PyThreadState* __tstate = wxPyBeginAllowThreads();
38082 (arg1)->SetSizer(arg2,arg3);
38083 wxPyEndAllowThreads(__tstate);
38084 if (PyErr_Occurred()) SWIG_fail;
38085 }
38086 resultobj = SWIG_Py_Void();
38087 return resultobj;
38088 fail:
38089 return NULL;
38090 }
38091
38092
38093 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38094 PyObject *resultobj = 0;
38095 wxWindow *arg1 = (wxWindow *) 0 ;
38096 wxSizer *arg2 = (wxSizer *) 0 ;
38097 bool arg3 = (bool) true ;
38098 void *argp1 = 0 ;
38099 int res1 = 0 ;
38100 int res2 = 0 ;
38101 bool val3 ;
38102 int ecode3 = 0 ;
38103 PyObject * obj0 = 0 ;
38104 PyObject * obj1 = 0 ;
38105 PyObject * obj2 = 0 ;
38106 char * kwnames[] = {
38107 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38108 };
38109
38110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38112 if (!SWIG_IsOK(res1)) {
38113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38114 }
38115 arg1 = reinterpret_cast< wxWindow * >(argp1);
38116 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38117 if (!SWIG_IsOK(res2)) {
38118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38119 }
38120 if (obj2) {
38121 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38122 if (!SWIG_IsOK(ecode3)) {
38123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38124 }
38125 arg3 = static_cast< bool >(val3);
38126 }
38127 {
38128 PyThreadState* __tstate = wxPyBeginAllowThreads();
38129 (arg1)->SetSizerAndFit(arg2,arg3);
38130 wxPyEndAllowThreads(__tstate);
38131 if (PyErr_Occurred()) SWIG_fail;
38132 }
38133 resultobj = SWIG_Py_Void();
38134 return resultobj;
38135 fail:
38136 return NULL;
38137 }
38138
38139
38140 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38141 PyObject *resultobj = 0;
38142 wxWindow *arg1 = (wxWindow *) 0 ;
38143 wxSizer *result = 0 ;
38144 void *argp1 = 0 ;
38145 int res1 = 0 ;
38146 PyObject *swig_obj[1] ;
38147
38148 if (!args) SWIG_fail;
38149 swig_obj[0] = args;
38150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38151 if (!SWIG_IsOK(res1)) {
38152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38153 }
38154 arg1 = reinterpret_cast< wxWindow * >(argp1);
38155 {
38156 PyThreadState* __tstate = wxPyBeginAllowThreads();
38157 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38158 wxPyEndAllowThreads(__tstate);
38159 if (PyErr_Occurred()) SWIG_fail;
38160 }
38161 {
38162 resultobj = wxPyMake_wxObject(result, (bool)0);
38163 }
38164 return resultobj;
38165 fail:
38166 return NULL;
38167 }
38168
38169
38170 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38171 PyObject *resultobj = 0;
38172 wxWindow *arg1 = (wxWindow *) 0 ;
38173 wxSizer *arg2 = (wxSizer *) 0 ;
38174 void *argp1 = 0 ;
38175 int res1 = 0 ;
38176 void *argp2 = 0 ;
38177 int res2 = 0 ;
38178 PyObject * obj0 = 0 ;
38179 PyObject * obj1 = 0 ;
38180 char * kwnames[] = {
38181 (char *) "self",(char *) "sizer", NULL
38182 };
38183
38184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38186 if (!SWIG_IsOK(res1)) {
38187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38188 }
38189 arg1 = reinterpret_cast< wxWindow * >(argp1);
38190 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38191 if (!SWIG_IsOK(res2)) {
38192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38193 }
38194 arg2 = reinterpret_cast< wxSizer * >(argp2);
38195 {
38196 PyThreadState* __tstate = wxPyBeginAllowThreads();
38197 (arg1)->SetContainingSizer(arg2);
38198 wxPyEndAllowThreads(__tstate);
38199 if (PyErr_Occurred()) SWIG_fail;
38200 }
38201 resultobj = SWIG_Py_Void();
38202 return resultobj;
38203 fail:
38204 return NULL;
38205 }
38206
38207
38208 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38209 PyObject *resultobj = 0;
38210 wxWindow *arg1 = (wxWindow *) 0 ;
38211 wxSizer *result = 0 ;
38212 void *argp1 = 0 ;
38213 int res1 = 0 ;
38214 PyObject *swig_obj[1] ;
38215
38216 if (!args) SWIG_fail;
38217 swig_obj[0] = args;
38218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38219 if (!SWIG_IsOK(res1)) {
38220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38221 }
38222 arg1 = reinterpret_cast< wxWindow * >(argp1);
38223 {
38224 PyThreadState* __tstate = wxPyBeginAllowThreads();
38225 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38226 wxPyEndAllowThreads(__tstate);
38227 if (PyErr_Occurred()) SWIG_fail;
38228 }
38229 {
38230 resultobj = wxPyMake_wxObject(result, (bool)0);
38231 }
38232 return resultobj;
38233 fail:
38234 return NULL;
38235 }
38236
38237
38238 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38239 PyObject *resultobj = 0;
38240 wxWindow *arg1 = (wxWindow *) 0 ;
38241 void *argp1 = 0 ;
38242 int res1 = 0 ;
38243 PyObject *swig_obj[1] ;
38244
38245 if (!args) SWIG_fail;
38246 swig_obj[0] = args;
38247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38248 if (!SWIG_IsOK(res1)) {
38249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38250 }
38251 arg1 = reinterpret_cast< wxWindow * >(argp1);
38252 {
38253 PyThreadState* __tstate = wxPyBeginAllowThreads();
38254 (arg1)->InheritAttributes();
38255 wxPyEndAllowThreads(__tstate);
38256 if (PyErr_Occurred()) SWIG_fail;
38257 }
38258 resultobj = SWIG_Py_Void();
38259 return resultobj;
38260 fail:
38261 return NULL;
38262 }
38263
38264
38265 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38266 PyObject *resultobj = 0;
38267 wxWindow *arg1 = (wxWindow *) 0 ;
38268 bool result;
38269 void *argp1 = 0 ;
38270 int res1 = 0 ;
38271 PyObject *swig_obj[1] ;
38272
38273 if (!args) SWIG_fail;
38274 swig_obj[0] = args;
38275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38276 if (!SWIG_IsOK(res1)) {
38277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38278 }
38279 arg1 = reinterpret_cast< wxWindow * >(argp1);
38280 {
38281 PyThreadState* __tstate = wxPyBeginAllowThreads();
38282 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38283 wxPyEndAllowThreads(__tstate);
38284 if (PyErr_Occurred()) SWIG_fail;
38285 }
38286 {
38287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38288 }
38289 return resultobj;
38290 fail:
38291 return NULL;
38292 }
38293
38294
38295 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38296 PyObject *resultobj = 0;
38297 wxWindow *arg1 = (wxWindow *) 0 ;
38298 bool result;
38299 void *argp1 = 0 ;
38300 int res1 = 0 ;
38301 PyObject *swig_obj[1] ;
38302
38303 if (!args) SWIG_fail;
38304 swig_obj[0] = args;
38305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38306 if (!SWIG_IsOK(res1)) {
38307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38308 }
38309 arg1 = reinterpret_cast< wxWindow * >(argp1);
38310 {
38311 PyThreadState* __tstate = wxPyBeginAllowThreads();
38312 result = (bool)(arg1)->CanSetTransparent();
38313 wxPyEndAllowThreads(__tstate);
38314 if (PyErr_Occurred()) SWIG_fail;
38315 }
38316 {
38317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38318 }
38319 return resultobj;
38320 fail:
38321 return NULL;
38322 }
38323
38324
38325 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38326 PyObject *resultobj = 0;
38327 wxWindow *arg1 = (wxWindow *) 0 ;
38328 byte arg2 ;
38329 bool result;
38330 void *argp1 = 0 ;
38331 int res1 = 0 ;
38332 unsigned char val2 ;
38333 int ecode2 = 0 ;
38334 PyObject * obj0 = 0 ;
38335 PyObject * obj1 = 0 ;
38336 char * kwnames[] = {
38337 (char *) "self",(char *) "alpha", NULL
38338 };
38339
38340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38342 if (!SWIG_IsOK(res1)) {
38343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38344 }
38345 arg1 = reinterpret_cast< wxWindow * >(argp1);
38346 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38347 if (!SWIG_IsOK(ecode2)) {
38348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38349 }
38350 arg2 = static_cast< byte >(val2);
38351 {
38352 PyThreadState* __tstate = wxPyBeginAllowThreads();
38353 result = (bool)(arg1)->SetTransparent(arg2);
38354 wxPyEndAllowThreads(__tstate);
38355 if (PyErr_Occurred()) SWIG_fail;
38356 }
38357 {
38358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38359 }
38360 return resultobj;
38361 fail:
38362 return NULL;
38363 }
38364
38365
38366 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38367 PyObject *obj;
38368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38369 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38370 return SWIG_Py_Void();
38371 }
38372
38373 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38374 return SWIG_Python_InitShadowInstance(args);
38375 }
38376
38377 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38378 PyObject *resultobj = 0;
38379 long arg1 ;
38380 wxWindow *arg2 = (wxWindow *) NULL ;
38381 wxWindow *result = 0 ;
38382 long val1 ;
38383 int ecode1 = 0 ;
38384 void *argp2 = 0 ;
38385 int res2 = 0 ;
38386 PyObject * obj0 = 0 ;
38387 PyObject * obj1 = 0 ;
38388 char * kwnames[] = {
38389 (char *) "id",(char *) "parent", NULL
38390 };
38391
38392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38393 ecode1 = SWIG_AsVal_long(obj0, &val1);
38394 if (!SWIG_IsOK(ecode1)) {
38395 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38396 }
38397 arg1 = static_cast< long >(val1);
38398 if (obj1) {
38399 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38400 if (!SWIG_IsOK(res2)) {
38401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38402 }
38403 arg2 = reinterpret_cast< wxWindow * >(argp2);
38404 }
38405 {
38406 if (!wxPyCheckForApp()) SWIG_fail;
38407 PyThreadState* __tstate = wxPyBeginAllowThreads();
38408 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38409 wxPyEndAllowThreads(__tstate);
38410 if (PyErr_Occurred()) SWIG_fail;
38411 }
38412 {
38413 resultobj = wxPyMake_wxObject(result, 0);
38414 }
38415 return resultobj;
38416 fail:
38417 return NULL;
38418 }
38419
38420
38421 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38422 PyObject *resultobj = 0;
38423 wxString *arg1 = 0 ;
38424 wxWindow *arg2 = (wxWindow *) NULL ;
38425 wxWindow *result = 0 ;
38426 bool temp1 = false ;
38427 void *argp2 = 0 ;
38428 int res2 = 0 ;
38429 PyObject * obj0 = 0 ;
38430 PyObject * obj1 = 0 ;
38431 char * kwnames[] = {
38432 (char *) "name",(char *) "parent", NULL
38433 };
38434
38435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38436 {
38437 arg1 = wxString_in_helper(obj0);
38438 if (arg1 == NULL) SWIG_fail;
38439 temp1 = true;
38440 }
38441 if (obj1) {
38442 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38443 if (!SWIG_IsOK(res2)) {
38444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38445 }
38446 arg2 = reinterpret_cast< wxWindow * >(argp2);
38447 }
38448 {
38449 if (!wxPyCheckForApp()) SWIG_fail;
38450 PyThreadState* __tstate = wxPyBeginAllowThreads();
38451 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38452 wxPyEndAllowThreads(__tstate);
38453 if (PyErr_Occurred()) SWIG_fail;
38454 }
38455 {
38456 resultobj = wxPyMake_wxObject(result, 0);
38457 }
38458 {
38459 if (temp1)
38460 delete arg1;
38461 }
38462 return resultobj;
38463 fail:
38464 {
38465 if (temp1)
38466 delete arg1;
38467 }
38468 return NULL;
38469 }
38470
38471
38472 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38473 PyObject *resultobj = 0;
38474 wxString *arg1 = 0 ;
38475 wxWindow *arg2 = (wxWindow *) NULL ;
38476 wxWindow *result = 0 ;
38477 bool temp1 = false ;
38478 void *argp2 = 0 ;
38479 int res2 = 0 ;
38480 PyObject * obj0 = 0 ;
38481 PyObject * obj1 = 0 ;
38482 char * kwnames[] = {
38483 (char *) "label",(char *) "parent", NULL
38484 };
38485
38486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38487 {
38488 arg1 = wxString_in_helper(obj0);
38489 if (arg1 == NULL) SWIG_fail;
38490 temp1 = true;
38491 }
38492 if (obj1) {
38493 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38494 if (!SWIG_IsOK(res2)) {
38495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38496 }
38497 arg2 = reinterpret_cast< wxWindow * >(argp2);
38498 }
38499 {
38500 if (!wxPyCheckForApp()) SWIG_fail;
38501 PyThreadState* __tstate = wxPyBeginAllowThreads();
38502 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38503 wxPyEndAllowThreads(__tstate);
38504 if (PyErr_Occurred()) SWIG_fail;
38505 }
38506 {
38507 resultobj = wxPyMake_wxObject(result, 0);
38508 }
38509 {
38510 if (temp1)
38511 delete arg1;
38512 }
38513 return resultobj;
38514 fail:
38515 {
38516 if (temp1)
38517 delete arg1;
38518 }
38519 return NULL;
38520 }
38521
38522
38523 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38524 PyObject *resultobj = 0;
38525 wxWindow *arg1 = (wxWindow *) 0 ;
38526 unsigned long arg2 ;
38527 wxWindow *result = 0 ;
38528 void *argp1 = 0 ;
38529 int res1 = 0 ;
38530 unsigned long val2 ;
38531 int ecode2 = 0 ;
38532 PyObject * obj0 = 0 ;
38533 PyObject * obj1 = 0 ;
38534 char * kwnames[] = {
38535 (char *) "parent",(char *) "_hWnd", NULL
38536 };
38537
38538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38540 if (!SWIG_IsOK(res1)) {
38541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38542 }
38543 arg1 = reinterpret_cast< wxWindow * >(argp1);
38544 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38545 if (!SWIG_IsOK(ecode2)) {
38546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38547 }
38548 arg2 = static_cast< unsigned long >(val2);
38549 {
38550 PyThreadState* __tstate = wxPyBeginAllowThreads();
38551 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38552 wxPyEndAllowThreads(__tstate);
38553 if (PyErr_Occurred()) SWIG_fail;
38554 }
38555 {
38556 resultobj = wxPyMake_wxObject(result, 0);
38557 }
38558 return resultobj;
38559 fail:
38560 return NULL;
38561 }
38562
38563
38564 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38565 PyObject *resultobj = 0;
38566 PyObject *result = 0 ;
38567
38568 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38569 {
38570 PyThreadState* __tstate = wxPyBeginAllowThreads();
38571 result = (PyObject *)GetTopLevelWindows();
38572 wxPyEndAllowThreads(__tstate);
38573 if (PyErr_Occurred()) SWIG_fail;
38574 }
38575 resultobj = result;
38576 return resultobj;
38577 fail:
38578 return NULL;
38579 }
38580
38581
38582 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38583 PyObject *resultobj = 0;
38584 wxValidator *result = 0 ;
38585
38586 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38587 {
38588 PyThreadState* __tstate = wxPyBeginAllowThreads();
38589 result = (wxValidator *)new wxValidator();
38590 wxPyEndAllowThreads(__tstate);
38591 if (PyErr_Occurred()) SWIG_fail;
38592 }
38593 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38594 return resultobj;
38595 fail:
38596 return NULL;
38597 }
38598
38599
38600 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38601 PyObject *resultobj = 0;
38602 wxValidator *arg1 = (wxValidator *) 0 ;
38603 wxValidator *result = 0 ;
38604 void *argp1 = 0 ;
38605 int res1 = 0 ;
38606 PyObject *swig_obj[1] ;
38607
38608 if (!args) SWIG_fail;
38609 swig_obj[0] = args;
38610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38611 if (!SWIG_IsOK(res1)) {
38612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38613 }
38614 arg1 = reinterpret_cast< wxValidator * >(argp1);
38615 {
38616 PyThreadState* __tstate = wxPyBeginAllowThreads();
38617 result = (wxValidator *)(arg1)->Clone();
38618 wxPyEndAllowThreads(__tstate);
38619 if (PyErr_Occurred()) SWIG_fail;
38620 }
38621 {
38622 resultobj = wxPyMake_wxObject(result, 0);
38623 }
38624 return resultobj;
38625 fail:
38626 return NULL;
38627 }
38628
38629
38630 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38631 PyObject *resultobj = 0;
38632 wxValidator *arg1 = (wxValidator *) 0 ;
38633 wxWindow *arg2 = (wxWindow *) 0 ;
38634 bool result;
38635 void *argp1 = 0 ;
38636 int res1 = 0 ;
38637 void *argp2 = 0 ;
38638 int res2 = 0 ;
38639 PyObject * obj0 = 0 ;
38640 PyObject * obj1 = 0 ;
38641 char * kwnames[] = {
38642 (char *) "self",(char *) "parent", NULL
38643 };
38644
38645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38647 if (!SWIG_IsOK(res1)) {
38648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38649 }
38650 arg1 = reinterpret_cast< wxValidator * >(argp1);
38651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38652 if (!SWIG_IsOK(res2)) {
38653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38654 }
38655 arg2 = reinterpret_cast< wxWindow * >(argp2);
38656 {
38657 PyThreadState* __tstate = wxPyBeginAllowThreads();
38658 result = (bool)(arg1)->Validate(arg2);
38659 wxPyEndAllowThreads(__tstate);
38660 if (PyErr_Occurred()) SWIG_fail;
38661 }
38662 {
38663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38664 }
38665 return resultobj;
38666 fail:
38667 return NULL;
38668 }
38669
38670
38671 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38672 PyObject *resultobj = 0;
38673 wxValidator *arg1 = (wxValidator *) 0 ;
38674 bool result;
38675 void *argp1 = 0 ;
38676 int res1 = 0 ;
38677 PyObject *swig_obj[1] ;
38678
38679 if (!args) SWIG_fail;
38680 swig_obj[0] = args;
38681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38682 if (!SWIG_IsOK(res1)) {
38683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38684 }
38685 arg1 = reinterpret_cast< wxValidator * >(argp1);
38686 {
38687 PyThreadState* __tstate = wxPyBeginAllowThreads();
38688 result = (bool)(arg1)->TransferToWindow();
38689 wxPyEndAllowThreads(__tstate);
38690 if (PyErr_Occurred()) SWIG_fail;
38691 }
38692 {
38693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38694 }
38695 return resultobj;
38696 fail:
38697 return NULL;
38698 }
38699
38700
38701 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38702 PyObject *resultobj = 0;
38703 wxValidator *arg1 = (wxValidator *) 0 ;
38704 bool result;
38705 void *argp1 = 0 ;
38706 int res1 = 0 ;
38707 PyObject *swig_obj[1] ;
38708
38709 if (!args) SWIG_fail;
38710 swig_obj[0] = args;
38711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38712 if (!SWIG_IsOK(res1)) {
38713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38714 }
38715 arg1 = reinterpret_cast< wxValidator * >(argp1);
38716 {
38717 PyThreadState* __tstate = wxPyBeginAllowThreads();
38718 result = (bool)(arg1)->TransferFromWindow();
38719 wxPyEndAllowThreads(__tstate);
38720 if (PyErr_Occurred()) SWIG_fail;
38721 }
38722 {
38723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38724 }
38725 return resultobj;
38726 fail:
38727 return NULL;
38728 }
38729
38730
38731 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38732 PyObject *resultobj = 0;
38733 wxValidator *arg1 = (wxValidator *) 0 ;
38734 wxWindow *result = 0 ;
38735 void *argp1 = 0 ;
38736 int res1 = 0 ;
38737 PyObject *swig_obj[1] ;
38738
38739 if (!args) SWIG_fail;
38740 swig_obj[0] = args;
38741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38742 if (!SWIG_IsOK(res1)) {
38743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38744 }
38745 arg1 = reinterpret_cast< wxValidator * >(argp1);
38746 {
38747 PyThreadState* __tstate = wxPyBeginAllowThreads();
38748 result = (wxWindow *)(arg1)->GetWindow();
38749 wxPyEndAllowThreads(__tstate);
38750 if (PyErr_Occurred()) SWIG_fail;
38751 }
38752 {
38753 resultobj = wxPyMake_wxObject(result, 0);
38754 }
38755 return resultobj;
38756 fail:
38757 return NULL;
38758 }
38759
38760
38761 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38762 PyObject *resultobj = 0;
38763 wxValidator *arg1 = (wxValidator *) 0 ;
38764 wxWindow *arg2 = (wxWindow *) 0 ;
38765 void *argp1 = 0 ;
38766 int res1 = 0 ;
38767 void *argp2 = 0 ;
38768 int res2 = 0 ;
38769 PyObject * obj0 = 0 ;
38770 PyObject * obj1 = 0 ;
38771 char * kwnames[] = {
38772 (char *) "self",(char *) "window", NULL
38773 };
38774
38775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38777 if (!SWIG_IsOK(res1)) {
38778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38779 }
38780 arg1 = reinterpret_cast< wxValidator * >(argp1);
38781 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38782 if (!SWIG_IsOK(res2)) {
38783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38784 }
38785 arg2 = reinterpret_cast< wxWindow * >(argp2);
38786 {
38787 PyThreadState* __tstate = wxPyBeginAllowThreads();
38788 (arg1)->SetWindow(arg2);
38789 wxPyEndAllowThreads(__tstate);
38790 if (PyErr_Occurred()) SWIG_fail;
38791 }
38792 resultobj = SWIG_Py_Void();
38793 return resultobj;
38794 fail:
38795 return NULL;
38796 }
38797
38798
38799 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38800 PyObject *resultobj = 0;
38801 bool result;
38802
38803 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38804 {
38805 PyThreadState* __tstate = wxPyBeginAllowThreads();
38806 result = (bool)wxValidator::IsSilent();
38807 wxPyEndAllowThreads(__tstate);
38808 if (PyErr_Occurred()) SWIG_fail;
38809 }
38810 {
38811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38812 }
38813 return resultobj;
38814 fail:
38815 return NULL;
38816 }
38817
38818
38819 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38820 PyObject *resultobj = 0;
38821 int arg1 = (int) true ;
38822 int val1 ;
38823 int ecode1 = 0 ;
38824 PyObject * obj0 = 0 ;
38825 char * kwnames[] = {
38826 (char *) "doIt", NULL
38827 };
38828
38829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38830 if (obj0) {
38831 ecode1 = SWIG_AsVal_int(obj0, &val1);
38832 if (!SWIG_IsOK(ecode1)) {
38833 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38834 }
38835 arg1 = static_cast< int >(val1);
38836 }
38837 {
38838 PyThreadState* __tstate = wxPyBeginAllowThreads();
38839 wxValidator::SetBellOnError(arg1);
38840 wxPyEndAllowThreads(__tstate);
38841 if (PyErr_Occurred()) SWIG_fail;
38842 }
38843 resultobj = SWIG_Py_Void();
38844 return resultobj;
38845 fail:
38846 return NULL;
38847 }
38848
38849
38850 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38851 PyObject *obj;
38852 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38853 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38854 return SWIG_Py_Void();
38855 }
38856
38857 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38858 return SWIG_Python_InitShadowInstance(args);
38859 }
38860
38861 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38862 PyObject *resultobj = 0;
38863 wxPyValidator *result = 0 ;
38864
38865 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38866 {
38867 PyThreadState* __tstate = wxPyBeginAllowThreads();
38868 result = (wxPyValidator *)new wxPyValidator();
38869 wxPyEndAllowThreads(__tstate);
38870 if (PyErr_Occurred()) SWIG_fail;
38871 }
38872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38873 return resultobj;
38874 fail:
38875 return NULL;
38876 }
38877
38878
38879 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38880 PyObject *resultobj = 0;
38881 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38882 PyObject *arg2 = (PyObject *) 0 ;
38883 PyObject *arg3 = (PyObject *) 0 ;
38884 int arg4 = (int) true ;
38885 void *argp1 = 0 ;
38886 int res1 = 0 ;
38887 int val4 ;
38888 int ecode4 = 0 ;
38889 PyObject * obj0 = 0 ;
38890 PyObject * obj1 = 0 ;
38891 PyObject * obj2 = 0 ;
38892 PyObject * obj3 = 0 ;
38893 char * kwnames[] = {
38894 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38895 };
38896
38897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38899 if (!SWIG_IsOK(res1)) {
38900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38901 }
38902 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38903 arg2 = obj1;
38904 arg3 = obj2;
38905 if (obj3) {
38906 ecode4 = SWIG_AsVal_int(obj3, &val4);
38907 if (!SWIG_IsOK(ecode4)) {
38908 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38909 }
38910 arg4 = static_cast< int >(val4);
38911 }
38912 {
38913 PyThreadState* __tstate = wxPyBeginAllowThreads();
38914 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38915 wxPyEndAllowThreads(__tstate);
38916 if (PyErr_Occurred()) SWIG_fail;
38917 }
38918 resultobj = SWIG_Py_Void();
38919 return resultobj;
38920 fail:
38921 return NULL;
38922 }
38923
38924
38925 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38926 PyObject *obj;
38927 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38928 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38929 return SWIG_Py_Void();
38930 }
38931
38932 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38933 return SWIG_Python_InitShadowInstance(args);
38934 }
38935
38936 SWIGINTERN int DefaultValidator_set(PyObject *) {
38937 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38938 return 1;
38939 }
38940
38941
38942 SWIGINTERN PyObject *DefaultValidator_get(void) {
38943 PyObject *pyobj = 0;
38944
38945 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38946 return pyobj;
38947 }
38948
38949
38950 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38951 PyObject *resultobj = 0;
38952 wxString const &arg1_defvalue = wxPyEmptyString ;
38953 wxString *arg1 = (wxString *) &arg1_defvalue ;
38954 long arg2 = (long) 0 ;
38955 wxMenu *result = 0 ;
38956 bool temp1 = false ;
38957 long val2 ;
38958 int ecode2 = 0 ;
38959 PyObject * obj0 = 0 ;
38960 PyObject * obj1 = 0 ;
38961 char * kwnames[] = {
38962 (char *) "title",(char *) "style", NULL
38963 };
38964
38965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38966 if (obj0) {
38967 {
38968 arg1 = wxString_in_helper(obj0);
38969 if (arg1 == NULL) SWIG_fail;
38970 temp1 = true;
38971 }
38972 }
38973 if (obj1) {
38974 ecode2 = SWIG_AsVal_long(obj1, &val2);
38975 if (!SWIG_IsOK(ecode2)) {
38976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38977 }
38978 arg2 = static_cast< long >(val2);
38979 }
38980 {
38981 if (!wxPyCheckForApp()) SWIG_fail;
38982 PyThreadState* __tstate = wxPyBeginAllowThreads();
38983 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38984 wxPyEndAllowThreads(__tstate);
38985 if (PyErr_Occurred()) SWIG_fail;
38986 }
38987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38988 {
38989 if (temp1)
38990 delete arg1;
38991 }
38992 return resultobj;
38993 fail:
38994 {
38995 if (temp1)
38996 delete arg1;
38997 }
38998 return NULL;
38999 }
39000
39001
39002 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39003 PyObject *resultobj = 0;
39004 wxMenu *arg1 = (wxMenu *) 0 ;
39005 int arg2 ;
39006 wxString const &arg3_defvalue = wxPyEmptyString ;
39007 wxString *arg3 = (wxString *) &arg3_defvalue ;
39008 wxString const &arg4_defvalue = wxPyEmptyString ;
39009 wxString *arg4 = (wxString *) &arg4_defvalue ;
39010 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39011 wxMenuItem *result = 0 ;
39012 void *argp1 = 0 ;
39013 int res1 = 0 ;
39014 int val2 ;
39015 int ecode2 = 0 ;
39016 bool temp3 = false ;
39017 bool temp4 = false ;
39018 int val5 ;
39019 int ecode5 = 0 ;
39020 PyObject * obj0 = 0 ;
39021 PyObject * obj1 = 0 ;
39022 PyObject * obj2 = 0 ;
39023 PyObject * obj3 = 0 ;
39024 PyObject * obj4 = 0 ;
39025 char * kwnames[] = {
39026 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39027 };
39028
39029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39031 if (!SWIG_IsOK(res1)) {
39032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39033 }
39034 arg1 = reinterpret_cast< wxMenu * >(argp1);
39035 ecode2 = SWIG_AsVal_int(obj1, &val2);
39036 if (!SWIG_IsOK(ecode2)) {
39037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39038 }
39039 arg2 = static_cast< int >(val2);
39040 if (obj2) {
39041 {
39042 arg3 = wxString_in_helper(obj2);
39043 if (arg3 == NULL) SWIG_fail;
39044 temp3 = true;
39045 }
39046 }
39047 if (obj3) {
39048 {
39049 arg4 = wxString_in_helper(obj3);
39050 if (arg4 == NULL) SWIG_fail;
39051 temp4 = true;
39052 }
39053 }
39054 if (obj4) {
39055 ecode5 = SWIG_AsVal_int(obj4, &val5);
39056 if (!SWIG_IsOK(ecode5)) {
39057 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39058 }
39059 arg5 = static_cast< wxItemKind >(val5);
39060 }
39061 {
39062 PyThreadState* __tstate = wxPyBeginAllowThreads();
39063 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39064 wxPyEndAllowThreads(__tstate);
39065 if (PyErr_Occurred()) SWIG_fail;
39066 }
39067 {
39068 resultobj = wxPyMake_wxObject(result, (bool)0);
39069 }
39070 {
39071 if (temp3)
39072 delete arg3;
39073 }
39074 {
39075 if (temp4)
39076 delete arg4;
39077 }
39078 return resultobj;
39079 fail:
39080 {
39081 if (temp3)
39082 delete arg3;
39083 }
39084 {
39085 if (temp4)
39086 delete arg4;
39087 }
39088 return NULL;
39089 }
39090
39091
39092 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39093 PyObject *resultobj = 0;
39094 wxMenu *arg1 = (wxMenu *) 0 ;
39095 wxMenuItem *result = 0 ;
39096 void *argp1 = 0 ;
39097 int res1 = 0 ;
39098 PyObject *swig_obj[1] ;
39099
39100 if (!args) SWIG_fail;
39101 swig_obj[0] = args;
39102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39103 if (!SWIG_IsOK(res1)) {
39104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39105 }
39106 arg1 = reinterpret_cast< wxMenu * >(argp1);
39107 {
39108 PyThreadState* __tstate = wxPyBeginAllowThreads();
39109 result = (wxMenuItem *)(arg1)->AppendSeparator();
39110 wxPyEndAllowThreads(__tstate);
39111 if (PyErr_Occurred()) SWIG_fail;
39112 }
39113 {
39114 resultobj = wxPyMake_wxObject(result, (bool)0);
39115 }
39116 return resultobj;
39117 fail:
39118 return NULL;
39119 }
39120
39121
39122 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39123 PyObject *resultobj = 0;
39124 wxMenu *arg1 = (wxMenu *) 0 ;
39125 int arg2 ;
39126 wxString *arg3 = 0 ;
39127 wxString const &arg4_defvalue = wxPyEmptyString ;
39128 wxString *arg4 = (wxString *) &arg4_defvalue ;
39129 wxMenuItem *result = 0 ;
39130 void *argp1 = 0 ;
39131 int res1 = 0 ;
39132 int val2 ;
39133 int ecode2 = 0 ;
39134 bool temp3 = false ;
39135 bool temp4 = false ;
39136 PyObject * obj0 = 0 ;
39137 PyObject * obj1 = 0 ;
39138 PyObject * obj2 = 0 ;
39139 PyObject * obj3 = 0 ;
39140 char * kwnames[] = {
39141 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39142 };
39143
39144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39146 if (!SWIG_IsOK(res1)) {
39147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39148 }
39149 arg1 = reinterpret_cast< wxMenu * >(argp1);
39150 ecode2 = SWIG_AsVal_int(obj1, &val2);
39151 if (!SWIG_IsOK(ecode2)) {
39152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39153 }
39154 arg2 = static_cast< int >(val2);
39155 {
39156 arg3 = wxString_in_helper(obj2);
39157 if (arg3 == NULL) SWIG_fail;
39158 temp3 = true;
39159 }
39160 if (obj3) {
39161 {
39162 arg4 = wxString_in_helper(obj3);
39163 if (arg4 == NULL) SWIG_fail;
39164 temp4 = true;
39165 }
39166 }
39167 {
39168 PyThreadState* __tstate = wxPyBeginAllowThreads();
39169 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39170 wxPyEndAllowThreads(__tstate);
39171 if (PyErr_Occurred()) SWIG_fail;
39172 }
39173 {
39174 resultobj = wxPyMake_wxObject(result, (bool)0);
39175 }
39176 {
39177 if (temp3)
39178 delete arg3;
39179 }
39180 {
39181 if (temp4)
39182 delete arg4;
39183 }
39184 return resultobj;
39185 fail:
39186 {
39187 if (temp3)
39188 delete arg3;
39189 }
39190 {
39191 if (temp4)
39192 delete arg4;
39193 }
39194 return NULL;
39195 }
39196
39197
39198 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39199 PyObject *resultobj = 0;
39200 wxMenu *arg1 = (wxMenu *) 0 ;
39201 int arg2 ;
39202 wxString *arg3 = 0 ;
39203 wxString const &arg4_defvalue = wxPyEmptyString ;
39204 wxString *arg4 = (wxString *) &arg4_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 bool temp4 = false ;
39212 PyObject * obj0 = 0 ;
39213 PyObject * obj1 = 0 ;
39214 PyObject * obj2 = 0 ;
39215 PyObject * obj3 = 0 ;
39216 char * kwnames[] = {
39217 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39218 };
39219
39220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39222 if (!SWIG_IsOK(res1)) {
39223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39224 }
39225 arg1 = reinterpret_cast< wxMenu * >(argp1);
39226 ecode2 = SWIG_AsVal_int(obj1, &val2);
39227 if (!SWIG_IsOK(ecode2)) {
39228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39229 }
39230 arg2 = static_cast< int >(val2);
39231 {
39232 arg3 = wxString_in_helper(obj2);
39233 if (arg3 == NULL) SWIG_fail;
39234 temp3 = true;
39235 }
39236 if (obj3) {
39237 {
39238 arg4 = wxString_in_helper(obj3);
39239 if (arg4 == NULL) SWIG_fail;
39240 temp4 = true;
39241 }
39242 }
39243 {
39244 PyThreadState* __tstate = wxPyBeginAllowThreads();
39245 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39246 wxPyEndAllowThreads(__tstate);
39247 if (PyErr_Occurred()) SWIG_fail;
39248 }
39249 {
39250 resultobj = wxPyMake_wxObject(result, (bool)0);
39251 }
39252 {
39253 if (temp3)
39254 delete arg3;
39255 }
39256 {
39257 if (temp4)
39258 delete arg4;
39259 }
39260 return resultobj;
39261 fail:
39262 {
39263 if (temp3)
39264 delete arg3;
39265 }
39266 {
39267 if (temp4)
39268 delete arg4;
39269 }
39270 return NULL;
39271 }
39272
39273
39274 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39275 PyObject *resultobj = 0;
39276 wxMenu *arg1 = (wxMenu *) 0 ;
39277 int arg2 ;
39278 wxString *arg3 = 0 ;
39279 wxMenu *arg4 = (wxMenu *) 0 ;
39280 wxString const &arg5_defvalue = wxPyEmptyString ;
39281 wxString *arg5 = (wxString *) &arg5_defvalue ;
39282 wxMenuItem *result = 0 ;
39283 void *argp1 = 0 ;
39284 int res1 = 0 ;
39285 int val2 ;
39286 int ecode2 = 0 ;
39287 bool temp3 = false ;
39288 void *argp4 = 0 ;
39289 int res4 = 0 ;
39290 bool temp5 = false ;
39291 PyObject * obj0 = 0 ;
39292 PyObject * obj1 = 0 ;
39293 PyObject * obj2 = 0 ;
39294 PyObject * obj3 = 0 ;
39295 PyObject * obj4 = 0 ;
39296 char * kwnames[] = {
39297 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39298 };
39299
39300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39302 if (!SWIG_IsOK(res1)) {
39303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39304 }
39305 arg1 = reinterpret_cast< wxMenu * >(argp1);
39306 ecode2 = SWIG_AsVal_int(obj1, &val2);
39307 if (!SWIG_IsOK(ecode2)) {
39308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39309 }
39310 arg2 = static_cast< int >(val2);
39311 {
39312 arg3 = wxString_in_helper(obj2);
39313 if (arg3 == NULL) SWIG_fail;
39314 temp3 = true;
39315 }
39316 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39317 if (!SWIG_IsOK(res4)) {
39318 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39319 }
39320 arg4 = reinterpret_cast< wxMenu * >(argp4);
39321 if (obj4) {
39322 {
39323 arg5 = wxString_in_helper(obj4);
39324 if (arg5 == NULL) SWIG_fail;
39325 temp5 = true;
39326 }
39327 }
39328 {
39329 PyThreadState* __tstate = wxPyBeginAllowThreads();
39330 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39331 wxPyEndAllowThreads(__tstate);
39332 if (PyErr_Occurred()) SWIG_fail;
39333 }
39334 {
39335 resultobj = wxPyMake_wxObject(result, (bool)0);
39336 }
39337 {
39338 if (temp3)
39339 delete arg3;
39340 }
39341 {
39342 if (temp5)
39343 delete arg5;
39344 }
39345 return resultobj;
39346 fail:
39347 {
39348 if (temp3)
39349 delete arg3;
39350 }
39351 {
39352 if (temp5)
39353 delete arg5;
39354 }
39355 return NULL;
39356 }
39357
39358
39359 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39360 PyObject *resultobj = 0;
39361 wxMenu *arg1 = (wxMenu *) 0 ;
39362 wxMenu *arg2 = (wxMenu *) 0 ;
39363 wxString *arg3 = 0 ;
39364 wxString const &arg4_defvalue = wxPyEmptyString ;
39365 wxString *arg4 = (wxString *) &arg4_defvalue ;
39366 wxMenuItem *result = 0 ;
39367 void *argp1 = 0 ;
39368 int res1 = 0 ;
39369 void *argp2 = 0 ;
39370 int res2 = 0 ;
39371 bool temp3 = false ;
39372 bool temp4 = false ;
39373 PyObject * obj0 = 0 ;
39374 PyObject * obj1 = 0 ;
39375 PyObject * obj2 = 0 ;
39376 PyObject * obj3 = 0 ;
39377 char * kwnames[] = {
39378 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39379 };
39380
39381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39383 if (!SWIG_IsOK(res1)) {
39384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39385 }
39386 arg1 = reinterpret_cast< wxMenu * >(argp1);
39387 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39388 if (!SWIG_IsOK(res2)) {
39389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39390 }
39391 arg2 = reinterpret_cast< wxMenu * >(argp2);
39392 {
39393 arg3 = wxString_in_helper(obj2);
39394 if (arg3 == NULL) SWIG_fail;
39395 temp3 = true;
39396 }
39397 if (obj3) {
39398 {
39399 arg4 = wxString_in_helper(obj3);
39400 if (arg4 == NULL) SWIG_fail;
39401 temp4 = true;
39402 }
39403 }
39404 {
39405 PyThreadState* __tstate = wxPyBeginAllowThreads();
39406 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39407 wxPyEndAllowThreads(__tstate);
39408 if (PyErr_Occurred()) SWIG_fail;
39409 }
39410 {
39411 resultobj = wxPyMake_wxObject(result, (bool)0);
39412 }
39413 {
39414 if (temp3)
39415 delete arg3;
39416 }
39417 {
39418 if (temp4)
39419 delete arg4;
39420 }
39421 return resultobj;
39422 fail:
39423 {
39424 if (temp3)
39425 delete arg3;
39426 }
39427 {
39428 if (temp4)
39429 delete arg4;
39430 }
39431 return NULL;
39432 }
39433
39434
39435 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39436 PyObject *resultobj = 0;
39437 wxMenu *arg1 = (wxMenu *) 0 ;
39438 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39439 wxMenuItem *result = 0 ;
39440 void *argp1 = 0 ;
39441 int res1 = 0 ;
39442 int res2 = 0 ;
39443 PyObject * obj0 = 0 ;
39444 PyObject * obj1 = 0 ;
39445 char * kwnames[] = {
39446 (char *) "self",(char *) "item", NULL
39447 };
39448
39449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39451 if (!SWIG_IsOK(res1)) {
39452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39453 }
39454 arg1 = reinterpret_cast< wxMenu * >(argp1);
39455 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39456 if (!SWIG_IsOK(res2)) {
39457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39458 }
39459 {
39460 PyThreadState* __tstate = wxPyBeginAllowThreads();
39461 result = (wxMenuItem *)(arg1)->Append(arg2);
39462 wxPyEndAllowThreads(__tstate);
39463 if (PyErr_Occurred()) SWIG_fail;
39464 }
39465 {
39466 resultobj = wxPyMake_wxObject(result, (bool)0);
39467 }
39468 return resultobj;
39469 fail:
39470 return NULL;
39471 }
39472
39473
39474 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39475 PyObject *resultobj = 0;
39476 wxMenu *arg1 = (wxMenu *) 0 ;
39477 size_t arg2 ;
39478 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39479 wxMenuItem *result = 0 ;
39480 void *argp1 = 0 ;
39481 int res1 = 0 ;
39482 size_t val2 ;
39483 int ecode2 = 0 ;
39484 int res3 = 0 ;
39485 PyObject * obj0 = 0 ;
39486 PyObject * obj1 = 0 ;
39487 PyObject * obj2 = 0 ;
39488 char * kwnames[] = {
39489 (char *) "self",(char *) "pos",(char *) "item", NULL
39490 };
39491
39492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39494 if (!SWIG_IsOK(res1)) {
39495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39496 }
39497 arg1 = reinterpret_cast< wxMenu * >(argp1);
39498 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39499 if (!SWIG_IsOK(ecode2)) {
39500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39501 }
39502 arg2 = static_cast< size_t >(val2);
39503 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39504 if (!SWIG_IsOK(res3)) {
39505 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39506 }
39507 {
39508 PyThreadState* __tstate = wxPyBeginAllowThreads();
39509 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39510 wxPyEndAllowThreads(__tstate);
39511 if (PyErr_Occurred()) SWIG_fail;
39512 }
39513 {
39514 resultobj = wxPyMake_wxObject(result, (bool)0);
39515 }
39516 return resultobj;
39517 fail:
39518 return NULL;
39519 }
39520
39521
39522 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39523 PyObject *resultobj = 0;
39524 wxMenu *arg1 = (wxMenu *) 0 ;
39525 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39526 wxMenuItem *result = 0 ;
39527 void *argp1 = 0 ;
39528 int res1 = 0 ;
39529 int res2 = 0 ;
39530 PyObject * obj0 = 0 ;
39531 PyObject * obj1 = 0 ;
39532 char * kwnames[] = {
39533 (char *) "self",(char *) "item", NULL
39534 };
39535
39536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39538 if (!SWIG_IsOK(res1)) {
39539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39540 }
39541 arg1 = reinterpret_cast< wxMenu * >(argp1);
39542 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39543 if (!SWIG_IsOK(res2)) {
39544 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39545 }
39546 {
39547 PyThreadState* __tstate = wxPyBeginAllowThreads();
39548 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39549 wxPyEndAllowThreads(__tstate);
39550 if (PyErr_Occurred()) SWIG_fail;
39551 }
39552 {
39553 resultobj = wxPyMake_wxObject(result, (bool)0);
39554 }
39555 return resultobj;
39556 fail:
39557 return NULL;
39558 }
39559
39560
39561 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39562 PyObject *resultobj = 0;
39563 wxMenu *arg1 = (wxMenu *) 0 ;
39564 void *argp1 = 0 ;
39565 int res1 = 0 ;
39566 PyObject *swig_obj[1] ;
39567
39568 if (!args) SWIG_fail;
39569 swig_obj[0] = args;
39570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39571 if (!SWIG_IsOK(res1)) {
39572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39573 }
39574 arg1 = reinterpret_cast< wxMenu * >(argp1);
39575 {
39576 PyThreadState* __tstate = wxPyBeginAllowThreads();
39577 (arg1)->Break();
39578 wxPyEndAllowThreads(__tstate);
39579 if (PyErr_Occurred()) SWIG_fail;
39580 }
39581 resultobj = SWIG_Py_Void();
39582 return resultobj;
39583 fail:
39584 return NULL;
39585 }
39586
39587
39588 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39589 PyObject *resultobj = 0;
39590 wxMenu *arg1 = (wxMenu *) 0 ;
39591 size_t arg2 ;
39592 int arg3 ;
39593 wxString const &arg4_defvalue = wxPyEmptyString ;
39594 wxString *arg4 = (wxString *) &arg4_defvalue ;
39595 wxString const &arg5_defvalue = wxPyEmptyString ;
39596 wxString *arg5 = (wxString *) &arg5_defvalue ;
39597 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39598 wxMenuItem *result = 0 ;
39599 void *argp1 = 0 ;
39600 int res1 = 0 ;
39601 size_t val2 ;
39602 int ecode2 = 0 ;
39603 int val3 ;
39604 int ecode3 = 0 ;
39605 bool temp4 = false ;
39606 bool temp5 = false ;
39607 int val6 ;
39608 int ecode6 = 0 ;
39609 PyObject * obj0 = 0 ;
39610 PyObject * obj1 = 0 ;
39611 PyObject * obj2 = 0 ;
39612 PyObject * obj3 = 0 ;
39613 PyObject * obj4 = 0 ;
39614 PyObject * obj5 = 0 ;
39615 char * kwnames[] = {
39616 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39617 };
39618
39619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39621 if (!SWIG_IsOK(res1)) {
39622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39623 }
39624 arg1 = reinterpret_cast< wxMenu * >(argp1);
39625 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39626 if (!SWIG_IsOK(ecode2)) {
39627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39628 }
39629 arg2 = static_cast< size_t >(val2);
39630 ecode3 = SWIG_AsVal_int(obj2, &val3);
39631 if (!SWIG_IsOK(ecode3)) {
39632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39633 }
39634 arg3 = static_cast< int >(val3);
39635 if (obj3) {
39636 {
39637 arg4 = wxString_in_helper(obj3);
39638 if (arg4 == NULL) SWIG_fail;
39639 temp4 = true;
39640 }
39641 }
39642 if (obj4) {
39643 {
39644 arg5 = wxString_in_helper(obj4);
39645 if (arg5 == NULL) SWIG_fail;
39646 temp5 = true;
39647 }
39648 }
39649 if (obj5) {
39650 ecode6 = SWIG_AsVal_int(obj5, &val6);
39651 if (!SWIG_IsOK(ecode6)) {
39652 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39653 }
39654 arg6 = static_cast< wxItemKind >(val6);
39655 }
39656 {
39657 PyThreadState* __tstate = wxPyBeginAllowThreads();
39658 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39659 wxPyEndAllowThreads(__tstate);
39660 if (PyErr_Occurred()) SWIG_fail;
39661 }
39662 {
39663 resultobj = wxPyMake_wxObject(result, (bool)0);
39664 }
39665 {
39666 if (temp4)
39667 delete arg4;
39668 }
39669 {
39670 if (temp5)
39671 delete arg5;
39672 }
39673 return resultobj;
39674 fail:
39675 {
39676 if (temp4)
39677 delete arg4;
39678 }
39679 {
39680 if (temp5)
39681 delete arg5;
39682 }
39683 return NULL;
39684 }
39685
39686
39687 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39688 PyObject *resultobj = 0;
39689 wxMenu *arg1 = (wxMenu *) 0 ;
39690 size_t arg2 ;
39691 wxMenuItem *result = 0 ;
39692 void *argp1 = 0 ;
39693 int res1 = 0 ;
39694 size_t val2 ;
39695 int ecode2 = 0 ;
39696 PyObject * obj0 = 0 ;
39697 PyObject * obj1 = 0 ;
39698 char * kwnames[] = {
39699 (char *) "self",(char *) "pos", NULL
39700 };
39701
39702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39704 if (!SWIG_IsOK(res1)) {
39705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39706 }
39707 arg1 = reinterpret_cast< wxMenu * >(argp1);
39708 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39709 if (!SWIG_IsOK(ecode2)) {
39710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39711 }
39712 arg2 = static_cast< size_t >(val2);
39713 {
39714 PyThreadState* __tstate = wxPyBeginAllowThreads();
39715 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39716 wxPyEndAllowThreads(__tstate);
39717 if (PyErr_Occurred()) SWIG_fail;
39718 }
39719 {
39720 resultobj = wxPyMake_wxObject(result, (bool)0);
39721 }
39722 return resultobj;
39723 fail:
39724 return NULL;
39725 }
39726
39727
39728 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39729 PyObject *resultobj = 0;
39730 wxMenu *arg1 = (wxMenu *) 0 ;
39731 size_t arg2 ;
39732 int arg3 ;
39733 wxString *arg4 = 0 ;
39734 wxString const &arg5_defvalue = wxPyEmptyString ;
39735 wxString *arg5 = (wxString *) &arg5_defvalue ;
39736 wxMenuItem *result = 0 ;
39737 void *argp1 = 0 ;
39738 int res1 = 0 ;
39739 size_t val2 ;
39740 int ecode2 = 0 ;
39741 int val3 ;
39742 int ecode3 = 0 ;
39743 bool temp4 = false ;
39744 bool temp5 = false ;
39745 PyObject * obj0 = 0 ;
39746 PyObject * obj1 = 0 ;
39747 PyObject * obj2 = 0 ;
39748 PyObject * obj3 = 0 ;
39749 PyObject * obj4 = 0 ;
39750 char * kwnames[] = {
39751 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39752 };
39753
39754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39756 if (!SWIG_IsOK(res1)) {
39757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39758 }
39759 arg1 = reinterpret_cast< wxMenu * >(argp1);
39760 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39761 if (!SWIG_IsOK(ecode2)) {
39762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39763 }
39764 arg2 = static_cast< size_t >(val2);
39765 ecode3 = SWIG_AsVal_int(obj2, &val3);
39766 if (!SWIG_IsOK(ecode3)) {
39767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39768 }
39769 arg3 = static_cast< int >(val3);
39770 {
39771 arg4 = wxString_in_helper(obj3);
39772 if (arg4 == NULL) SWIG_fail;
39773 temp4 = true;
39774 }
39775 if (obj4) {
39776 {
39777 arg5 = wxString_in_helper(obj4);
39778 if (arg5 == NULL) SWIG_fail;
39779 temp5 = true;
39780 }
39781 }
39782 {
39783 PyThreadState* __tstate = wxPyBeginAllowThreads();
39784 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39785 wxPyEndAllowThreads(__tstate);
39786 if (PyErr_Occurred()) SWIG_fail;
39787 }
39788 {
39789 resultobj = wxPyMake_wxObject(result, (bool)0);
39790 }
39791 {
39792 if (temp4)
39793 delete arg4;
39794 }
39795 {
39796 if (temp5)
39797 delete arg5;
39798 }
39799 return resultobj;
39800 fail:
39801 {
39802 if (temp4)
39803 delete arg4;
39804 }
39805 {
39806 if (temp5)
39807 delete arg5;
39808 }
39809 return NULL;
39810 }
39811
39812
39813 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39814 PyObject *resultobj = 0;
39815 wxMenu *arg1 = (wxMenu *) 0 ;
39816 size_t arg2 ;
39817 int arg3 ;
39818 wxString *arg4 = 0 ;
39819 wxString const &arg5_defvalue = wxPyEmptyString ;
39820 wxString *arg5 = (wxString *) &arg5_defvalue ;
39821 wxMenuItem *result = 0 ;
39822 void *argp1 = 0 ;
39823 int res1 = 0 ;
39824 size_t val2 ;
39825 int ecode2 = 0 ;
39826 int val3 ;
39827 int ecode3 = 0 ;
39828 bool temp4 = false ;
39829 bool temp5 = false ;
39830 PyObject * obj0 = 0 ;
39831 PyObject * obj1 = 0 ;
39832 PyObject * obj2 = 0 ;
39833 PyObject * obj3 = 0 ;
39834 PyObject * obj4 = 0 ;
39835 char * kwnames[] = {
39836 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39837 };
39838
39839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39841 if (!SWIG_IsOK(res1)) {
39842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39843 }
39844 arg1 = reinterpret_cast< wxMenu * >(argp1);
39845 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39846 if (!SWIG_IsOK(ecode2)) {
39847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39848 }
39849 arg2 = static_cast< size_t >(val2);
39850 ecode3 = SWIG_AsVal_int(obj2, &val3);
39851 if (!SWIG_IsOK(ecode3)) {
39852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39853 }
39854 arg3 = static_cast< int >(val3);
39855 {
39856 arg4 = wxString_in_helper(obj3);
39857 if (arg4 == NULL) SWIG_fail;
39858 temp4 = true;
39859 }
39860 if (obj4) {
39861 {
39862 arg5 = wxString_in_helper(obj4);
39863 if (arg5 == NULL) SWIG_fail;
39864 temp5 = true;
39865 }
39866 }
39867 {
39868 PyThreadState* __tstate = wxPyBeginAllowThreads();
39869 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39870 wxPyEndAllowThreads(__tstate);
39871 if (PyErr_Occurred()) SWIG_fail;
39872 }
39873 {
39874 resultobj = wxPyMake_wxObject(result, (bool)0);
39875 }
39876 {
39877 if (temp4)
39878 delete arg4;
39879 }
39880 {
39881 if (temp5)
39882 delete arg5;
39883 }
39884 return resultobj;
39885 fail:
39886 {
39887 if (temp4)
39888 delete arg4;
39889 }
39890 {
39891 if (temp5)
39892 delete arg5;
39893 }
39894 return NULL;
39895 }
39896
39897
39898 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39899 PyObject *resultobj = 0;
39900 wxMenu *arg1 = (wxMenu *) 0 ;
39901 size_t arg2 ;
39902 int arg3 ;
39903 wxString *arg4 = 0 ;
39904 wxMenu *arg5 = (wxMenu *) 0 ;
39905 wxString const &arg6_defvalue = wxPyEmptyString ;
39906 wxString *arg6 = (wxString *) &arg6_defvalue ;
39907 wxMenuItem *result = 0 ;
39908 void *argp1 = 0 ;
39909 int res1 = 0 ;
39910 size_t val2 ;
39911 int ecode2 = 0 ;
39912 int val3 ;
39913 int ecode3 = 0 ;
39914 bool temp4 = false ;
39915 void *argp5 = 0 ;
39916 int res5 = 0 ;
39917 bool temp6 = false ;
39918 PyObject * obj0 = 0 ;
39919 PyObject * obj1 = 0 ;
39920 PyObject * obj2 = 0 ;
39921 PyObject * obj3 = 0 ;
39922 PyObject * obj4 = 0 ;
39923 PyObject * obj5 = 0 ;
39924 char * kwnames[] = {
39925 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39926 };
39927
39928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39930 if (!SWIG_IsOK(res1)) {
39931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39932 }
39933 arg1 = reinterpret_cast< wxMenu * >(argp1);
39934 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39935 if (!SWIG_IsOK(ecode2)) {
39936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39937 }
39938 arg2 = static_cast< size_t >(val2);
39939 ecode3 = SWIG_AsVal_int(obj2, &val3);
39940 if (!SWIG_IsOK(ecode3)) {
39941 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39942 }
39943 arg3 = static_cast< int >(val3);
39944 {
39945 arg4 = wxString_in_helper(obj3);
39946 if (arg4 == NULL) SWIG_fail;
39947 temp4 = true;
39948 }
39949 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39950 if (!SWIG_IsOK(res5)) {
39951 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39952 }
39953 arg5 = reinterpret_cast< wxMenu * >(argp5);
39954 if (obj5) {
39955 {
39956 arg6 = wxString_in_helper(obj5);
39957 if (arg6 == NULL) SWIG_fail;
39958 temp6 = true;
39959 }
39960 }
39961 {
39962 PyThreadState* __tstate = wxPyBeginAllowThreads();
39963 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39964 wxPyEndAllowThreads(__tstate);
39965 if (PyErr_Occurred()) SWIG_fail;
39966 }
39967 {
39968 resultobj = wxPyMake_wxObject(result, (bool)0);
39969 }
39970 {
39971 if (temp4)
39972 delete arg4;
39973 }
39974 {
39975 if (temp6)
39976 delete arg6;
39977 }
39978 return resultobj;
39979 fail:
39980 {
39981 if (temp4)
39982 delete arg4;
39983 }
39984 {
39985 if (temp6)
39986 delete arg6;
39987 }
39988 return NULL;
39989 }
39990
39991
39992 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39993 PyObject *resultobj = 0;
39994 wxMenu *arg1 = (wxMenu *) 0 ;
39995 int arg2 ;
39996 wxString const &arg3_defvalue = wxPyEmptyString ;
39997 wxString *arg3 = (wxString *) &arg3_defvalue ;
39998 wxString const &arg4_defvalue = wxPyEmptyString ;
39999 wxString *arg4 = (wxString *) &arg4_defvalue ;
40000 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
40001 wxMenuItem *result = 0 ;
40002 void *argp1 = 0 ;
40003 int res1 = 0 ;
40004 int val2 ;
40005 int ecode2 = 0 ;
40006 bool temp3 = false ;
40007 bool temp4 = false ;
40008 int val5 ;
40009 int ecode5 = 0 ;
40010 PyObject * obj0 = 0 ;
40011 PyObject * obj1 = 0 ;
40012 PyObject * obj2 = 0 ;
40013 PyObject * obj3 = 0 ;
40014 PyObject * obj4 = 0 ;
40015 char * kwnames[] = {
40016 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40017 };
40018
40019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40021 if (!SWIG_IsOK(res1)) {
40022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40023 }
40024 arg1 = reinterpret_cast< wxMenu * >(argp1);
40025 ecode2 = SWIG_AsVal_int(obj1, &val2);
40026 if (!SWIG_IsOK(ecode2)) {
40027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40028 }
40029 arg2 = static_cast< int >(val2);
40030 if (obj2) {
40031 {
40032 arg3 = wxString_in_helper(obj2);
40033 if (arg3 == NULL) SWIG_fail;
40034 temp3 = true;
40035 }
40036 }
40037 if (obj3) {
40038 {
40039 arg4 = wxString_in_helper(obj3);
40040 if (arg4 == NULL) SWIG_fail;
40041 temp4 = true;
40042 }
40043 }
40044 if (obj4) {
40045 ecode5 = SWIG_AsVal_int(obj4, &val5);
40046 if (!SWIG_IsOK(ecode5)) {
40047 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40048 }
40049 arg5 = static_cast< wxItemKind >(val5);
40050 }
40051 {
40052 PyThreadState* __tstate = wxPyBeginAllowThreads();
40053 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40054 wxPyEndAllowThreads(__tstate);
40055 if (PyErr_Occurred()) SWIG_fail;
40056 }
40057 {
40058 resultobj = wxPyMake_wxObject(result, (bool)0);
40059 }
40060 {
40061 if (temp3)
40062 delete arg3;
40063 }
40064 {
40065 if (temp4)
40066 delete arg4;
40067 }
40068 return resultobj;
40069 fail:
40070 {
40071 if (temp3)
40072 delete arg3;
40073 }
40074 {
40075 if (temp4)
40076 delete arg4;
40077 }
40078 return NULL;
40079 }
40080
40081
40082 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40083 PyObject *resultobj = 0;
40084 wxMenu *arg1 = (wxMenu *) 0 ;
40085 wxMenuItem *result = 0 ;
40086 void *argp1 = 0 ;
40087 int res1 = 0 ;
40088 PyObject *swig_obj[1] ;
40089
40090 if (!args) SWIG_fail;
40091 swig_obj[0] = args;
40092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40093 if (!SWIG_IsOK(res1)) {
40094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40095 }
40096 arg1 = reinterpret_cast< wxMenu * >(argp1);
40097 {
40098 PyThreadState* __tstate = wxPyBeginAllowThreads();
40099 result = (wxMenuItem *)(arg1)->PrependSeparator();
40100 wxPyEndAllowThreads(__tstate);
40101 if (PyErr_Occurred()) SWIG_fail;
40102 }
40103 {
40104 resultobj = wxPyMake_wxObject(result, (bool)0);
40105 }
40106 return resultobj;
40107 fail:
40108 return NULL;
40109 }
40110
40111
40112 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40113 PyObject *resultobj = 0;
40114 wxMenu *arg1 = (wxMenu *) 0 ;
40115 int arg2 ;
40116 wxString *arg3 = 0 ;
40117 wxString const &arg4_defvalue = wxPyEmptyString ;
40118 wxString *arg4 = (wxString *) &arg4_defvalue ;
40119 wxMenuItem *result = 0 ;
40120 void *argp1 = 0 ;
40121 int res1 = 0 ;
40122 int val2 ;
40123 int ecode2 = 0 ;
40124 bool temp3 = false ;
40125 bool temp4 = false ;
40126 PyObject * obj0 = 0 ;
40127 PyObject * obj1 = 0 ;
40128 PyObject * obj2 = 0 ;
40129 PyObject * obj3 = 0 ;
40130 char * kwnames[] = {
40131 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40132 };
40133
40134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40136 if (!SWIG_IsOK(res1)) {
40137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40138 }
40139 arg1 = reinterpret_cast< wxMenu * >(argp1);
40140 ecode2 = SWIG_AsVal_int(obj1, &val2);
40141 if (!SWIG_IsOK(ecode2)) {
40142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40143 }
40144 arg2 = static_cast< int >(val2);
40145 {
40146 arg3 = wxString_in_helper(obj2);
40147 if (arg3 == NULL) SWIG_fail;
40148 temp3 = true;
40149 }
40150 if (obj3) {
40151 {
40152 arg4 = wxString_in_helper(obj3);
40153 if (arg4 == NULL) SWIG_fail;
40154 temp4 = true;
40155 }
40156 }
40157 {
40158 PyThreadState* __tstate = wxPyBeginAllowThreads();
40159 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40160 wxPyEndAllowThreads(__tstate);
40161 if (PyErr_Occurred()) SWIG_fail;
40162 }
40163 {
40164 resultobj = wxPyMake_wxObject(result, (bool)0);
40165 }
40166 {
40167 if (temp3)
40168 delete arg3;
40169 }
40170 {
40171 if (temp4)
40172 delete arg4;
40173 }
40174 return resultobj;
40175 fail:
40176 {
40177 if (temp3)
40178 delete arg3;
40179 }
40180 {
40181 if (temp4)
40182 delete arg4;
40183 }
40184 return NULL;
40185 }
40186
40187
40188 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40189 PyObject *resultobj = 0;
40190 wxMenu *arg1 = (wxMenu *) 0 ;
40191 int arg2 ;
40192 wxString *arg3 = 0 ;
40193 wxString const &arg4_defvalue = wxPyEmptyString ;
40194 wxString *arg4 = (wxString *) &arg4_defvalue ;
40195 wxMenuItem *result = 0 ;
40196 void *argp1 = 0 ;
40197 int res1 = 0 ;
40198 int val2 ;
40199 int ecode2 = 0 ;
40200 bool temp3 = false ;
40201 bool temp4 = false ;
40202 PyObject * obj0 = 0 ;
40203 PyObject * obj1 = 0 ;
40204 PyObject * obj2 = 0 ;
40205 PyObject * obj3 = 0 ;
40206 char * kwnames[] = {
40207 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40208 };
40209
40210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40212 if (!SWIG_IsOK(res1)) {
40213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40214 }
40215 arg1 = reinterpret_cast< wxMenu * >(argp1);
40216 ecode2 = SWIG_AsVal_int(obj1, &val2);
40217 if (!SWIG_IsOK(ecode2)) {
40218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40219 }
40220 arg2 = static_cast< int >(val2);
40221 {
40222 arg3 = wxString_in_helper(obj2);
40223 if (arg3 == NULL) SWIG_fail;
40224 temp3 = true;
40225 }
40226 if (obj3) {
40227 {
40228 arg4 = wxString_in_helper(obj3);
40229 if (arg4 == NULL) SWIG_fail;
40230 temp4 = true;
40231 }
40232 }
40233 {
40234 PyThreadState* __tstate = wxPyBeginAllowThreads();
40235 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40236 wxPyEndAllowThreads(__tstate);
40237 if (PyErr_Occurred()) SWIG_fail;
40238 }
40239 {
40240 resultobj = wxPyMake_wxObject(result, (bool)0);
40241 }
40242 {
40243 if (temp3)
40244 delete arg3;
40245 }
40246 {
40247 if (temp4)
40248 delete arg4;
40249 }
40250 return resultobj;
40251 fail:
40252 {
40253 if (temp3)
40254 delete arg3;
40255 }
40256 {
40257 if (temp4)
40258 delete arg4;
40259 }
40260 return NULL;
40261 }
40262
40263
40264 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40265 PyObject *resultobj = 0;
40266 wxMenu *arg1 = (wxMenu *) 0 ;
40267 int arg2 ;
40268 wxString *arg3 = 0 ;
40269 wxMenu *arg4 = (wxMenu *) 0 ;
40270 wxString const &arg5_defvalue = wxPyEmptyString ;
40271 wxString *arg5 = (wxString *) &arg5_defvalue ;
40272 wxMenuItem *result = 0 ;
40273 void *argp1 = 0 ;
40274 int res1 = 0 ;
40275 int val2 ;
40276 int ecode2 = 0 ;
40277 bool temp3 = false ;
40278 void *argp4 = 0 ;
40279 int res4 = 0 ;
40280 bool temp5 = false ;
40281 PyObject * obj0 = 0 ;
40282 PyObject * obj1 = 0 ;
40283 PyObject * obj2 = 0 ;
40284 PyObject * obj3 = 0 ;
40285 PyObject * obj4 = 0 ;
40286 char * kwnames[] = {
40287 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40288 };
40289
40290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40292 if (!SWIG_IsOK(res1)) {
40293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40294 }
40295 arg1 = reinterpret_cast< wxMenu * >(argp1);
40296 ecode2 = SWIG_AsVal_int(obj1, &val2);
40297 if (!SWIG_IsOK(ecode2)) {
40298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40299 }
40300 arg2 = static_cast< int >(val2);
40301 {
40302 arg3 = wxString_in_helper(obj2);
40303 if (arg3 == NULL) SWIG_fail;
40304 temp3 = true;
40305 }
40306 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40307 if (!SWIG_IsOK(res4)) {
40308 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40309 }
40310 arg4 = reinterpret_cast< wxMenu * >(argp4);
40311 if (obj4) {
40312 {
40313 arg5 = wxString_in_helper(obj4);
40314 if (arg5 == NULL) SWIG_fail;
40315 temp5 = true;
40316 }
40317 }
40318 {
40319 PyThreadState* __tstate = wxPyBeginAllowThreads();
40320 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40321 wxPyEndAllowThreads(__tstate);
40322 if (PyErr_Occurred()) SWIG_fail;
40323 }
40324 {
40325 resultobj = wxPyMake_wxObject(result, (bool)0);
40326 }
40327 {
40328 if (temp3)
40329 delete arg3;
40330 }
40331 {
40332 if (temp5)
40333 delete arg5;
40334 }
40335 return resultobj;
40336 fail:
40337 {
40338 if (temp3)
40339 delete arg3;
40340 }
40341 {
40342 if (temp5)
40343 delete arg5;
40344 }
40345 return NULL;
40346 }
40347
40348
40349 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40350 PyObject *resultobj = 0;
40351 wxMenu *arg1 = (wxMenu *) 0 ;
40352 int arg2 ;
40353 wxMenuItem *result = 0 ;
40354 void *argp1 = 0 ;
40355 int res1 = 0 ;
40356 int val2 ;
40357 int ecode2 = 0 ;
40358 PyObject * obj0 = 0 ;
40359 PyObject * obj1 = 0 ;
40360 char * kwnames[] = {
40361 (char *) "self",(char *) "id", NULL
40362 };
40363
40364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40366 if (!SWIG_IsOK(res1)) {
40367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40368 }
40369 arg1 = reinterpret_cast< wxMenu * >(argp1);
40370 ecode2 = SWIG_AsVal_int(obj1, &val2);
40371 if (!SWIG_IsOK(ecode2)) {
40372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40373 }
40374 arg2 = static_cast< int >(val2);
40375 {
40376 PyThreadState* __tstate = wxPyBeginAllowThreads();
40377 result = (wxMenuItem *)(arg1)->Remove(arg2);
40378 wxPyEndAllowThreads(__tstate);
40379 if (PyErr_Occurred()) SWIG_fail;
40380 }
40381 {
40382 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40383 }
40384 return resultobj;
40385 fail:
40386 return NULL;
40387 }
40388
40389
40390 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40391 PyObject *resultobj = 0;
40392 wxMenu *arg1 = (wxMenu *) 0 ;
40393 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40394 wxMenuItem *result = 0 ;
40395 void *argp1 = 0 ;
40396 int res1 = 0 ;
40397 void *argp2 = 0 ;
40398 int res2 = 0 ;
40399 PyObject * obj0 = 0 ;
40400 PyObject * obj1 = 0 ;
40401 char * kwnames[] = {
40402 (char *) "self",(char *) "item", NULL
40403 };
40404
40405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40407 if (!SWIG_IsOK(res1)) {
40408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40409 }
40410 arg1 = reinterpret_cast< wxMenu * >(argp1);
40411 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40412 if (!SWIG_IsOK(res2)) {
40413 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40414 }
40415 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40416 {
40417 PyThreadState* __tstate = wxPyBeginAllowThreads();
40418 result = (wxMenuItem *)(arg1)->Remove(arg2);
40419 wxPyEndAllowThreads(__tstate);
40420 if (PyErr_Occurred()) SWIG_fail;
40421 }
40422 {
40423 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40424 }
40425 return resultobj;
40426 fail:
40427 return NULL;
40428 }
40429
40430
40431 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40432 PyObject *resultobj = 0;
40433 wxMenu *arg1 = (wxMenu *) 0 ;
40434 int arg2 ;
40435 bool result;
40436 void *argp1 = 0 ;
40437 int res1 = 0 ;
40438 int val2 ;
40439 int ecode2 = 0 ;
40440 PyObject * obj0 = 0 ;
40441 PyObject * obj1 = 0 ;
40442 char * kwnames[] = {
40443 (char *) "self",(char *) "id", NULL
40444 };
40445
40446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40448 if (!SWIG_IsOK(res1)) {
40449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40450 }
40451 arg1 = reinterpret_cast< wxMenu * >(argp1);
40452 ecode2 = SWIG_AsVal_int(obj1, &val2);
40453 if (!SWIG_IsOK(ecode2)) {
40454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40455 }
40456 arg2 = static_cast< int >(val2);
40457 {
40458 PyThreadState* __tstate = wxPyBeginAllowThreads();
40459 result = (bool)(arg1)->Delete(arg2);
40460 wxPyEndAllowThreads(__tstate);
40461 if (PyErr_Occurred()) SWIG_fail;
40462 }
40463 {
40464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40465 }
40466 return resultobj;
40467 fail:
40468 return NULL;
40469 }
40470
40471
40472 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40473 PyObject *resultobj = 0;
40474 wxMenu *arg1 = (wxMenu *) 0 ;
40475 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40476 bool result;
40477 void *argp1 = 0 ;
40478 int res1 = 0 ;
40479 void *argp2 = 0 ;
40480 int res2 = 0 ;
40481 PyObject * obj0 = 0 ;
40482 PyObject * obj1 = 0 ;
40483 char * kwnames[] = {
40484 (char *) "self",(char *) "item", NULL
40485 };
40486
40487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40489 if (!SWIG_IsOK(res1)) {
40490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40491 }
40492 arg1 = reinterpret_cast< wxMenu * >(argp1);
40493 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40494 if (!SWIG_IsOK(res2)) {
40495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40496 }
40497 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40498 {
40499 PyThreadState* __tstate = wxPyBeginAllowThreads();
40500 result = (bool)(arg1)->Delete(arg2);
40501 wxPyEndAllowThreads(__tstate);
40502 if (PyErr_Occurred()) SWIG_fail;
40503 }
40504 {
40505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40506 }
40507 return resultobj;
40508 fail:
40509 return NULL;
40510 }
40511
40512
40513 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40514 PyObject *resultobj = 0;
40515 wxMenu *arg1 = (wxMenu *) 0 ;
40516 void *argp1 = 0 ;
40517 int res1 = 0 ;
40518 PyObject *swig_obj[1] ;
40519
40520 if (!args) SWIG_fail;
40521 swig_obj[0] = args;
40522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40523 if (!SWIG_IsOK(res1)) {
40524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40525 }
40526 arg1 = reinterpret_cast< wxMenu * >(argp1);
40527 {
40528 PyThreadState* __tstate = wxPyBeginAllowThreads();
40529 wxMenu_Destroy(arg1);
40530 wxPyEndAllowThreads(__tstate);
40531 if (PyErr_Occurred()) SWIG_fail;
40532 }
40533 resultobj = SWIG_Py_Void();
40534 return resultobj;
40535 fail:
40536 return NULL;
40537 }
40538
40539
40540 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40541 PyObject *resultobj = 0;
40542 wxMenu *arg1 = (wxMenu *) 0 ;
40543 int arg2 ;
40544 bool result;
40545 void *argp1 = 0 ;
40546 int res1 = 0 ;
40547 int val2 ;
40548 int ecode2 = 0 ;
40549 PyObject * obj0 = 0 ;
40550 PyObject * obj1 = 0 ;
40551 char * kwnames[] = {
40552 (char *) "self",(char *) "id", NULL
40553 };
40554
40555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40557 if (!SWIG_IsOK(res1)) {
40558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40559 }
40560 arg1 = reinterpret_cast< wxMenu * >(argp1);
40561 ecode2 = SWIG_AsVal_int(obj1, &val2);
40562 if (!SWIG_IsOK(ecode2)) {
40563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40564 }
40565 arg2 = static_cast< int >(val2);
40566 {
40567 PyThreadState* __tstate = wxPyBeginAllowThreads();
40568 result = (bool)(arg1)->Destroy(arg2);
40569 wxPyEndAllowThreads(__tstate);
40570 if (PyErr_Occurred()) SWIG_fail;
40571 }
40572 {
40573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40574 }
40575 return resultobj;
40576 fail:
40577 return NULL;
40578 }
40579
40580
40581 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40582 PyObject *resultobj = 0;
40583 wxMenu *arg1 = (wxMenu *) 0 ;
40584 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40585 bool result;
40586 void *argp1 = 0 ;
40587 int res1 = 0 ;
40588 void *argp2 = 0 ;
40589 int res2 = 0 ;
40590 PyObject * obj0 = 0 ;
40591 PyObject * obj1 = 0 ;
40592 char * kwnames[] = {
40593 (char *) "self",(char *) "item", NULL
40594 };
40595
40596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40598 if (!SWIG_IsOK(res1)) {
40599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40600 }
40601 arg1 = reinterpret_cast< wxMenu * >(argp1);
40602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40603 if (!SWIG_IsOK(res2)) {
40604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40605 }
40606 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40607 {
40608 PyThreadState* __tstate = wxPyBeginAllowThreads();
40609 result = (bool)(arg1)->Destroy(arg2);
40610 wxPyEndAllowThreads(__tstate);
40611 if (PyErr_Occurred()) SWIG_fail;
40612 }
40613 {
40614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40615 }
40616 return resultobj;
40617 fail:
40618 return NULL;
40619 }
40620
40621
40622 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40623 PyObject *resultobj = 0;
40624 wxMenu *arg1 = (wxMenu *) 0 ;
40625 size_t result;
40626 void *argp1 = 0 ;
40627 int res1 = 0 ;
40628 PyObject *swig_obj[1] ;
40629
40630 if (!args) SWIG_fail;
40631 swig_obj[0] = args;
40632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40633 if (!SWIG_IsOK(res1)) {
40634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40635 }
40636 arg1 = reinterpret_cast< wxMenu * >(argp1);
40637 {
40638 PyThreadState* __tstate = wxPyBeginAllowThreads();
40639 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40640 wxPyEndAllowThreads(__tstate);
40641 if (PyErr_Occurred()) SWIG_fail;
40642 }
40643 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40644 return resultobj;
40645 fail:
40646 return NULL;
40647 }
40648
40649
40650 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40651 PyObject *resultobj = 0;
40652 wxMenu *arg1 = (wxMenu *) 0 ;
40653 PyObject *result = 0 ;
40654 void *argp1 = 0 ;
40655 int res1 = 0 ;
40656 PyObject *swig_obj[1] ;
40657
40658 if (!args) SWIG_fail;
40659 swig_obj[0] = args;
40660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40661 if (!SWIG_IsOK(res1)) {
40662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40663 }
40664 arg1 = reinterpret_cast< wxMenu * >(argp1);
40665 {
40666 PyThreadState* __tstate = wxPyBeginAllowThreads();
40667 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40668 wxPyEndAllowThreads(__tstate);
40669 if (PyErr_Occurred()) SWIG_fail;
40670 }
40671 resultobj = result;
40672 return resultobj;
40673 fail:
40674 return NULL;
40675 }
40676
40677
40678 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40679 PyObject *resultobj = 0;
40680 wxMenu *arg1 = (wxMenu *) 0 ;
40681 wxString *arg2 = 0 ;
40682 int result;
40683 void *argp1 = 0 ;
40684 int res1 = 0 ;
40685 bool temp2 = false ;
40686 PyObject * obj0 = 0 ;
40687 PyObject * obj1 = 0 ;
40688 char * kwnames[] = {
40689 (char *) "self",(char *) "item", NULL
40690 };
40691
40692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40694 if (!SWIG_IsOK(res1)) {
40695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40696 }
40697 arg1 = reinterpret_cast< wxMenu * >(argp1);
40698 {
40699 arg2 = wxString_in_helper(obj1);
40700 if (arg2 == NULL) SWIG_fail;
40701 temp2 = true;
40702 }
40703 {
40704 PyThreadState* __tstate = wxPyBeginAllowThreads();
40705 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40706 wxPyEndAllowThreads(__tstate);
40707 if (PyErr_Occurred()) SWIG_fail;
40708 }
40709 resultobj = SWIG_From_int(static_cast< int >(result));
40710 {
40711 if (temp2)
40712 delete arg2;
40713 }
40714 return resultobj;
40715 fail:
40716 {
40717 if (temp2)
40718 delete arg2;
40719 }
40720 return NULL;
40721 }
40722
40723
40724 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40725 PyObject *resultobj = 0;
40726 wxMenu *arg1 = (wxMenu *) 0 ;
40727 int arg2 ;
40728 wxMenuItem *result = 0 ;
40729 void *argp1 = 0 ;
40730 int res1 = 0 ;
40731 int val2 ;
40732 int ecode2 = 0 ;
40733 PyObject * obj0 = 0 ;
40734 PyObject * obj1 = 0 ;
40735 char * kwnames[] = {
40736 (char *) "self",(char *) "id", NULL
40737 };
40738
40739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40741 if (!SWIG_IsOK(res1)) {
40742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40743 }
40744 arg1 = reinterpret_cast< wxMenu * >(argp1);
40745 ecode2 = SWIG_AsVal_int(obj1, &val2);
40746 if (!SWIG_IsOK(ecode2)) {
40747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40748 }
40749 arg2 = static_cast< int >(val2);
40750 {
40751 PyThreadState* __tstate = wxPyBeginAllowThreads();
40752 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40753 wxPyEndAllowThreads(__tstate);
40754 if (PyErr_Occurred()) SWIG_fail;
40755 }
40756 {
40757 resultobj = wxPyMake_wxObject(result, (bool)0);
40758 }
40759 return resultobj;
40760 fail:
40761 return NULL;
40762 }
40763
40764
40765 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40766 PyObject *resultobj = 0;
40767 wxMenu *arg1 = (wxMenu *) 0 ;
40768 size_t arg2 ;
40769 wxMenuItem *result = 0 ;
40770 void *argp1 = 0 ;
40771 int res1 = 0 ;
40772 size_t val2 ;
40773 int ecode2 = 0 ;
40774 PyObject * obj0 = 0 ;
40775 PyObject * obj1 = 0 ;
40776 char * kwnames[] = {
40777 (char *) "self",(char *) "position", NULL
40778 };
40779
40780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40782 if (!SWIG_IsOK(res1)) {
40783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40784 }
40785 arg1 = reinterpret_cast< wxMenu * >(argp1);
40786 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40787 if (!SWIG_IsOK(ecode2)) {
40788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40789 }
40790 arg2 = static_cast< size_t >(val2);
40791 {
40792 PyThreadState* __tstate = wxPyBeginAllowThreads();
40793 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40794 wxPyEndAllowThreads(__tstate);
40795 if (PyErr_Occurred()) SWIG_fail;
40796 }
40797 {
40798 resultobj = wxPyMake_wxObject(result, (bool)0);
40799 }
40800 return resultobj;
40801 fail:
40802 return NULL;
40803 }
40804
40805
40806 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40807 PyObject *resultobj = 0;
40808 wxMenu *arg1 = (wxMenu *) 0 ;
40809 int arg2 ;
40810 bool arg3 ;
40811 void *argp1 = 0 ;
40812 int res1 = 0 ;
40813 int val2 ;
40814 int ecode2 = 0 ;
40815 bool val3 ;
40816 int ecode3 = 0 ;
40817 PyObject * obj0 = 0 ;
40818 PyObject * obj1 = 0 ;
40819 PyObject * obj2 = 0 ;
40820 char * kwnames[] = {
40821 (char *) "self",(char *) "id",(char *) "enable", NULL
40822 };
40823
40824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40826 if (!SWIG_IsOK(res1)) {
40827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40828 }
40829 arg1 = reinterpret_cast< wxMenu * >(argp1);
40830 ecode2 = SWIG_AsVal_int(obj1, &val2);
40831 if (!SWIG_IsOK(ecode2)) {
40832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40833 }
40834 arg2 = static_cast< int >(val2);
40835 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40836 if (!SWIG_IsOK(ecode3)) {
40837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40838 }
40839 arg3 = static_cast< bool >(val3);
40840 {
40841 PyThreadState* __tstate = wxPyBeginAllowThreads();
40842 (arg1)->Enable(arg2,arg3);
40843 wxPyEndAllowThreads(__tstate);
40844 if (PyErr_Occurred()) SWIG_fail;
40845 }
40846 resultobj = SWIG_Py_Void();
40847 return resultobj;
40848 fail:
40849 return NULL;
40850 }
40851
40852
40853 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40854 PyObject *resultobj = 0;
40855 wxMenu *arg1 = (wxMenu *) 0 ;
40856 int arg2 ;
40857 bool result;
40858 void *argp1 = 0 ;
40859 int res1 = 0 ;
40860 int val2 ;
40861 int ecode2 = 0 ;
40862 PyObject * obj0 = 0 ;
40863 PyObject * obj1 = 0 ;
40864 char * kwnames[] = {
40865 (char *) "self",(char *) "id", NULL
40866 };
40867
40868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40870 if (!SWIG_IsOK(res1)) {
40871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40872 }
40873 arg1 = reinterpret_cast< wxMenu * >(argp1);
40874 ecode2 = SWIG_AsVal_int(obj1, &val2);
40875 if (!SWIG_IsOK(ecode2)) {
40876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40877 }
40878 arg2 = static_cast< int >(val2);
40879 {
40880 PyThreadState* __tstate = wxPyBeginAllowThreads();
40881 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40882 wxPyEndAllowThreads(__tstate);
40883 if (PyErr_Occurred()) SWIG_fail;
40884 }
40885 {
40886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40887 }
40888 return resultobj;
40889 fail:
40890 return NULL;
40891 }
40892
40893
40894 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40895 PyObject *resultobj = 0;
40896 wxMenu *arg1 = (wxMenu *) 0 ;
40897 int arg2 ;
40898 bool arg3 ;
40899 void *argp1 = 0 ;
40900 int res1 = 0 ;
40901 int val2 ;
40902 int ecode2 = 0 ;
40903 bool val3 ;
40904 int ecode3 = 0 ;
40905 PyObject * obj0 = 0 ;
40906 PyObject * obj1 = 0 ;
40907 PyObject * obj2 = 0 ;
40908 char * kwnames[] = {
40909 (char *) "self",(char *) "id",(char *) "check", NULL
40910 };
40911
40912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40914 if (!SWIG_IsOK(res1)) {
40915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40916 }
40917 arg1 = reinterpret_cast< wxMenu * >(argp1);
40918 ecode2 = SWIG_AsVal_int(obj1, &val2);
40919 if (!SWIG_IsOK(ecode2)) {
40920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40921 }
40922 arg2 = static_cast< int >(val2);
40923 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40924 if (!SWIG_IsOK(ecode3)) {
40925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40926 }
40927 arg3 = static_cast< bool >(val3);
40928 {
40929 PyThreadState* __tstate = wxPyBeginAllowThreads();
40930 (arg1)->Check(arg2,arg3);
40931 wxPyEndAllowThreads(__tstate);
40932 if (PyErr_Occurred()) SWIG_fail;
40933 }
40934 resultobj = SWIG_Py_Void();
40935 return resultobj;
40936 fail:
40937 return NULL;
40938 }
40939
40940
40941 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40942 PyObject *resultobj = 0;
40943 wxMenu *arg1 = (wxMenu *) 0 ;
40944 int arg2 ;
40945 bool result;
40946 void *argp1 = 0 ;
40947 int res1 = 0 ;
40948 int val2 ;
40949 int ecode2 = 0 ;
40950 PyObject * obj0 = 0 ;
40951 PyObject * obj1 = 0 ;
40952 char * kwnames[] = {
40953 (char *) "self",(char *) "id", NULL
40954 };
40955
40956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40958 if (!SWIG_IsOK(res1)) {
40959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40960 }
40961 arg1 = reinterpret_cast< wxMenu * >(argp1);
40962 ecode2 = SWIG_AsVal_int(obj1, &val2);
40963 if (!SWIG_IsOK(ecode2)) {
40964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40965 }
40966 arg2 = static_cast< int >(val2);
40967 {
40968 PyThreadState* __tstate = wxPyBeginAllowThreads();
40969 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40970 wxPyEndAllowThreads(__tstate);
40971 if (PyErr_Occurred()) SWIG_fail;
40972 }
40973 {
40974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40975 }
40976 return resultobj;
40977 fail:
40978 return NULL;
40979 }
40980
40981
40982 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40983 PyObject *resultobj = 0;
40984 wxMenu *arg1 = (wxMenu *) 0 ;
40985 int arg2 ;
40986 wxString *arg3 = 0 ;
40987 void *argp1 = 0 ;
40988 int res1 = 0 ;
40989 int val2 ;
40990 int ecode2 = 0 ;
40991 bool temp3 = false ;
40992 PyObject * obj0 = 0 ;
40993 PyObject * obj1 = 0 ;
40994 PyObject * obj2 = 0 ;
40995 char * kwnames[] = {
40996 (char *) "self",(char *) "id",(char *) "label", NULL
40997 };
40998
40999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41001 if (!SWIG_IsOK(res1)) {
41002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
41003 }
41004 arg1 = reinterpret_cast< wxMenu * >(argp1);
41005 ecode2 = SWIG_AsVal_int(obj1, &val2);
41006 if (!SWIG_IsOK(ecode2)) {
41007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
41008 }
41009 arg2 = static_cast< int >(val2);
41010 {
41011 arg3 = wxString_in_helper(obj2);
41012 if (arg3 == NULL) SWIG_fail;
41013 temp3 = true;
41014 }
41015 {
41016 PyThreadState* __tstate = wxPyBeginAllowThreads();
41017 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41018 wxPyEndAllowThreads(__tstate);
41019 if (PyErr_Occurred()) SWIG_fail;
41020 }
41021 resultobj = SWIG_Py_Void();
41022 {
41023 if (temp3)
41024 delete arg3;
41025 }
41026 return resultobj;
41027 fail:
41028 {
41029 if (temp3)
41030 delete arg3;
41031 }
41032 return NULL;
41033 }
41034
41035
41036 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41037 PyObject *resultobj = 0;
41038 wxMenu *arg1 = (wxMenu *) 0 ;
41039 int arg2 ;
41040 wxString result;
41041 void *argp1 = 0 ;
41042 int res1 = 0 ;
41043 int val2 ;
41044 int ecode2 = 0 ;
41045 PyObject * obj0 = 0 ;
41046 PyObject * obj1 = 0 ;
41047 char * kwnames[] = {
41048 (char *) "self",(char *) "id", NULL
41049 };
41050
41051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41053 if (!SWIG_IsOK(res1)) {
41054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41055 }
41056 arg1 = reinterpret_cast< wxMenu * >(argp1);
41057 ecode2 = SWIG_AsVal_int(obj1, &val2);
41058 if (!SWIG_IsOK(ecode2)) {
41059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41060 }
41061 arg2 = static_cast< int >(val2);
41062 {
41063 PyThreadState* __tstate = wxPyBeginAllowThreads();
41064 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41065 wxPyEndAllowThreads(__tstate);
41066 if (PyErr_Occurred()) SWIG_fail;
41067 }
41068 {
41069 #if wxUSE_UNICODE
41070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41071 #else
41072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41073 #endif
41074 }
41075 return resultobj;
41076 fail:
41077 return NULL;
41078 }
41079
41080
41081 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41082 PyObject *resultobj = 0;
41083 wxMenu *arg1 = (wxMenu *) 0 ;
41084 int arg2 ;
41085 wxString *arg3 = 0 ;
41086 void *argp1 = 0 ;
41087 int res1 = 0 ;
41088 int val2 ;
41089 int ecode2 = 0 ;
41090 bool temp3 = false ;
41091 PyObject * obj0 = 0 ;
41092 PyObject * obj1 = 0 ;
41093 PyObject * obj2 = 0 ;
41094 char * kwnames[] = {
41095 (char *) "self",(char *) "id",(char *) "helpString", NULL
41096 };
41097
41098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41100 if (!SWIG_IsOK(res1)) {
41101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41102 }
41103 arg1 = reinterpret_cast< wxMenu * >(argp1);
41104 ecode2 = SWIG_AsVal_int(obj1, &val2);
41105 if (!SWIG_IsOK(ecode2)) {
41106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41107 }
41108 arg2 = static_cast< int >(val2);
41109 {
41110 arg3 = wxString_in_helper(obj2);
41111 if (arg3 == NULL) SWIG_fail;
41112 temp3 = true;
41113 }
41114 {
41115 PyThreadState* __tstate = wxPyBeginAllowThreads();
41116 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41117 wxPyEndAllowThreads(__tstate);
41118 if (PyErr_Occurred()) SWIG_fail;
41119 }
41120 resultobj = SWIG_Py_Void();
41121 {
41122 if (temp3)
41123 delete arg3;
41124 }
41125 return resultobj;
41126 fail:
41127 {
41128 if (temp3)
41129 delete arg3;
41130 }
41131 return NULL;
41132 }
41133
41134
41135 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41136 PyObject *resultobj = 0;
41137 wxMenu *arg1 = (wxMenu *) 0 ;
41138 int arg2 ;
41139 wxString result;
41140 void *argp1 = 0 ;
41141 int res1 = 0 ;
41142 int val2 ;
41143 int ecode2 = 0 ;
41144 PyObject * obj0 = 0 ;
41145 PyObject * obj1 = 0 ;
41146 char * kwnames[] = {
41147 (char *) "self",(char *) "id", NULL
41148 };
41149
41150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41152 if (!SWIG_IsOK(res1)) {
41153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41154 }
41155 arg1 = reinterpret_cast< wxMenu * >(argp1);
41156 ecode2 = SWIG_AsVal_int(obj1, &val2);
41157 if (!SWIG_IsOK(ecode2)) {
41158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41159 }
41160 arg2 = static_cast< int >(val2);
41161 {
41162 PyThreadState* __tstate = wxPyBeginAllowThreads();
41163 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41164 wxPyEndAllowThreads(__tstate);
41165 if (PyErr_Occurred()) SWIG_fail;
41166 }
41167 {
41168 #if wxUSE_UNICODE
41169 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41170 #else
41171 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41172 #endif
41173 }
41174 return resultobj;
41175 fail:
41176 return NULL;
41177 }
41178
41179
41180 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41181 PyObject *resultobj = 0;
41182 wxMenu *arg1 = (wxMenu *) 0 ;
41183 wxString *arg2 = 0 ;
41184 void *argp1 = 0 ;
41185 int res1 = 0 ;
41186 bool temp2 = false ;
41187 PyObject * obj0 = 0 ;
41188 PyObject * obj1 = 0 ;
41189 char * kwnames[] = {
41190 (char *) "self",(char *) "title", NULL
41191 };
41192
41193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41195 if (!SWIG_IsOK(res1)) {
41196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41197 }
41198 arg1 = reinterpret_cast< wxMenu * >(argp1);
41199 {
41200 arg2 = wxString_in_helper(obj1);
41201 if (arg2 == NULL) SWIG_fail;
41202 temp2 = true;
41203 }
41204 {
41205 PyThreadState* __tstate = wxPyBeginAllowThreads();
41206 (arg1)->SetTitle((wxString const &)*arg2);
41207 wxPyEndAllowThreads(__tstate);
41208 if (PyErr_Occurred()) SWIG_fail;
41209 }
41210 resultobj = SWIG_Py_Void();
41211 {
41212 if (temp2)
41213 delete arg2;
41214 }
41215 return resultobj;
41216 fail:
41217 {
41218 if (temp2)
41219 delete arg2;
41220 }
41221 return NULL;
41222 }
41223
41224
41225 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41226 PyObject *resultobj = 0;
41227 wxMenu *arg1 = (wxMenu *) 0 ;
41228 wxString result;
41229 void *argp1 = 0 ;
41230 int res1 = 0 ;
41231 PyObject *swig_obj[1] ;
41232
41233 if (!args) SWIG_fail;
41234 swig_obj[0] = args;
41235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41236 if (!SWIG_IsOK(res1)) {
41237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41238 }
41239 arg1 = reinterpret_cast< wxMenu * >(argp1);
41240 {
41241 PyThreadState* __tstate = wxPyBeginAllowThreads();
41242 result = ((wxMenu const *)arg1)->GetTitle();
41243 wxPyEndAllowThreads(__tstate);
41244 if (PyErr_Occurred()) SWIG_fail;
41245 }
41246 {
41247 #if wxUSE_UNICODE
41248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41249 #else
41250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41251 #endif
41252 }
41253 return resultobj;
41254 fail:
41255 return NULL;
41256 }
41257
41258
41259 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41260 PyObject *resultobj = 0;
41261 wxMenu *arg1 = (wxMenu *) 0 ;
41262 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41263 void *argp1 = 0 ;
41264 int res1 = 0 ;
41265 void *argp2 = 0 ;
41266 int res2 = 0 ;
41267 PyObject * obj0 = 0 ;
41268 PyObject * obj1 = 0 ;
41269 char * kwnames[] = {
41270 (char *) "self",(char *) "handler", NULL
41271 };
41272
41273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41275 if (!SWIG_IsOK(res1)) {
41276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41277 }
41278 arg1 = reinterpret_cast< wxMenu * >(argp1);
41279 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41280 if (!SWIG_IsOK(res2)) {
41281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41282 }
41283 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41284 {
41285 PyThreadState* __tstate = wxPyBeginAllowThreads();
41286 (arg1)->SetEventHandler(arg2);
41287 wxPyEndAllowThreads(__tstate);
41288 if (PyErr_Occurred()) SWIG_fail;
41289 }
41290 resultobj = SWIG_Py_Void();
41291 return resultobj;
41292 fail:
41293 return NULL;
41294 }
41295
41296
41297 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41298 PyObject *resultobj = 0;
41299 wxMenu *arg1 = (wxMenu *) 0 ;
41300 wxEvtHandler *result = 0 ;
41301 void *argp1 = 0 ;
41302 int res1 = 0 ;
41303 PyObject *swig_obj[1] ;
41304
41305 if (!args) SWIG_fail;
41306 swig_obj[0] = args;
41307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41308 if (!SWIG_IsOK(res1)) {
41309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41310 }
41311 arg1 = reinterpret_cast< wxMenu * >(argp1);
41312 {
41313 PyThreadState* __tstate = wxPyBeginAllowThreads();
41314 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41315 wxPyEndAllowThreads(__tstate);
41316 if (PyErr_Occurred()) SWIG_fail;
41317 }
41318 {
41319 resultobj = wxPyMake_wxObject(result, 0);
41320 }
41321 return resultobj;
41322 fail:
41323 return NULL;
41324 }
41325
41326
41327 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41328 PyObject *resultobj = 0;
41329 wxMenu *arg1 = (wxMenu *) 0 ;
41330 wxWindow *arg2 = (wxWindow *) 0 ;
41331 void *argp1 = 0 ;
41332 int res1 = 0 ;
41333 void *argp2 = 0 ;
41334 int res2 = 0 ;
41335 PyObject * obj0 = 0 ;
41336 PyObject * obj1 = 0 ;
41337 char * kwnames[] = {
41338 (char *) "self",(char *) "win", NULL
41339 };
41340
41341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41343 if (!SWIG_IsOK(res1)) {
41344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41345 }
41346 arg1 = reinterpret_cast< wxMenu * >(argp1);
41347 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41348 if (!SWIG_IsOK(res2)) {
41349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41350 }
41351 arg2 = reinterpret_cast< wxWindow * >(argp2);
41352 {
41353 PyThreadState* __tstate = wxPyBeginAllowThreads();
41354 (arg1)->SetInvokingWindow(arg2);
41355 wxPyEndAllowThreads(__tstate);
41356 if (PyErr_Occurred()) SWIG_fail;
41357 }
41358 resultobj = SWIG_Py_Void();
41359 return resultobj;
41360 fail:
41361 return NULL;
41362 }
41363
41364
41365 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41366 PyObject *resultobj = 0;
41367 wxMenu *arg1 = (wxMenu *) 0 ;
41368 wxWindow *result = 0 ;
41369 void *argp1 = 0 ;
41370 int res1 = 0 ;
41371 PyObject *swig_obj[1] ;
41372
41373 if (!args) SWIG_fail;
41374 swig_obj[0] = args;
41375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41376 if (!SWIG_IsOK(res1)) {
41377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41378 }
41379 arg1 = reinterpret_cast< wxMenu * >(argp1);
41380 {
41381 PyThreadState* __tstate = wxPyBeginAllowThreads();
41382 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41383 wxPyEndAllowThreads(__tstate);
41384 if (PyErr_Occurred()) SWIG_fail;
41385 }
41386 {
41387 resultobj = wxPyMake_wxObject(result, 0);
41388 }
41389 return resultobj;
41390 fail:
41391 return NULL;
41392 }
41393
41394
41395 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41396 PyObject *resultobj = 0;
41397 wxMenu *arg1 = (wxMenu *) 0 ;
41398 long result;
41399 void *argp1 = 0 ;
41400 int res1 = 0 ;
41401 PyObject *swig_obj[1] ;
41402
41403 if (!args) SWIG_fail;
41404 swig_obj[0] = args;
41405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41406 if (!SWIG_IsOK(res1)) {
41407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41408 }
41409 arg1 = reinterpret_cast< wxMenu * >(argp1);
41410 {
41411 PyThreadState* __tstate = wxPyBeginAllowThreads();
41412 result = (long)((wxMenu const *)arg1)->GetStyle();
41413 wxPyEndAllowThreads(__tstate);
41414 if (PyErr_Occurred()) SWIG_fail;
41415 }
41416 resultobj = SWIG_From_long(static_cast< long >(result));
41417 return resultobj;
41418 fail:
41419 return NULL;
41420 }
41421
41422
41423 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41424 PyObject *resultobj = 0;
41425 wxMenu *arg1 = (wxMenu *) 0 ;
41426 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41427 void *argp1 = 0 ;
41428 int res1 = 0 ;
41429 void *argp2 = 0 ;
41430 int res2 = 0 ;
41431 PyObject * obj0 = 0 ;
41432 PyObject * obj1 = 0 ;
41433 char * kwnames[] = {
41434 (char *) "self",(char *) "source", NULL
41435 };
41436
41437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41439 if (!SWIG_IsOK(res1)) {
41440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41441 }
41442 arg1 = reinterpret_cast< wxMenu * >(argp1);
41443 if (obj1) {
41444 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41445 if (!SWIG_IsOK(res2)) {
41446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41447 }
41448 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41449 }
41450 {
41451 PyThreadState* __tstate = wxPyBeginAllowThreads();
41452 (arg1)->UpdateUI(arg2);
41453 wxPyEndAllowThreads(__tstate);
41454 if (PyErr_Occurred()) SWIG_fail;
41455 }
41456 resultobj = SWIG_Py_Void();
41457 return resultobj;
41458 fail:
41459 return NULL;
41460 }
41461
41462
41463 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41464 PyObject *resultobj = 0;
41465 wxMenu *arg1 = (wxMenu *) 0 ;
41466 wxMenuBar *result = 0 ;
41467 void *argp1 = 0 ;
41468 int res1 = 0 ;
41469 PyObject *swig_obj[1] ;
41470
41471 if (!args) SWIG_fail;
41472 swig_obj[0] = args;
41473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41474 if (!SWIG_IsOK(res1)) {
41475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41476 }
41477 arg1 = reinterpret_cast< wxMenu * >(argp1);
41478 {
41479 PyThreadState* __tstate = wxPyBeginAllowThreads();
41480 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41481 wxPyEndAllowThreads(__tstate);
41482 if (PyErr_Occurred()) SWIG_fail;
41483 }
41484 {
41485 resultobj = wxPyMake_wxObject(result, (bool)0);
41486 }
41487 return resultobj;
41488 fail:
41489 return NULL;
41490 }
41491
41492
41493 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41494 PyObject *resultobj = 0;
41495 wxMenu *arg1 = (wxMenu *) 0 ;
41496 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41497 void *argp1 = 0 ;
41498 int res1 = 0 ;
41499 void *argp2 = 0 ;
41500 int res2 = 0 ;
41501 PyObject * obj0 = 0 ;
41502 PyObject * obj1 = 0 ;
41503 char * kwnames[] = {
41504 (char *) "self",(char *) "menubar", NULL
41505 };
41506
41507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41509 if (!SWIG_IsOK(res1)) {
41510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41511 }
41512 arg1 = reinterpret_cast< wxMenu * >(argp1);
41513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41514 if (!SWIG_IsOK(res2)) {
41515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41516 }
41517 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41518 {
41519 PyThreadState* __tstate = wxPyBeginAllowThreads();
41520 (arg1)->Attach(arg2);
41521 wxPyEndAllowThreads(__tstate);
41522 if (PyErr_Occurred()) SWIG_fail;
41523 }
41524 resultobj = SWIG_Py_Void();
41525 return resultobj;
41526 fail:
41527 return NULL;
41528 }
41529
41530
41531 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41532 PyObject *resultobj = 0;
41533 wxMenu *arg1 = (wxMenu *) 0 ;
41534 void *argp1 = 0 ;
41535 int res1 = 0 ;
41536 PyObject *swig_obj[1] ;
41537
41538 if (!args) SWIG_fail;
41539 swig_obj[0] = args;
41540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41541 if (!SWIG_IsOK(res1)) {
41542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41543 }
41544 arg1 = reinterpret_cast< wxMenu * >(argp1);
41545 {
41546 PyThreadState* __tstate = wxPyBeginAllowThreads();
41547 (arg1)->Detach();
41548 wxPyEndAllowThreads(__tstate);
41549 if (PyErr_Occurred()) SWIG_fail;
41550 }
41551 resultobj = SWIG_Py_Void();
41552 return resultobj;
41553 fail:
41554 return NULL;
41555 }
41556
41557
41558 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41559 PyObject *resultobj = 0;
41560 wxMenu *arg1 = (wxMenu *) 0 ;
41561 bool result;
41562 void *argp1 = 0 ;
41563 int res1 = 0 ;
41564 PyObject *swig_obj[1] ;
41565
41566 if (!args) SWIG_fail;
41567 swig_obj[0] = args;
41568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41569 if (!SWIG_IsOK(res1)) {
41570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41571 }
41572 arg1 = reinterpret_cast< wxMenu * >(argp1);
41573 {
41574 PyThreadState* __tstate = wxPyBeginAllowThreads();
41575 result = (bool)((wxMenu const *)arg1)->IsAttached();
41576 wxPyEndAllowThreads(__tstate);
41577 if (PyErr_Occurred()) SWIG_fail;
41578 }
41579 {
41580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41581 }
41582 return resultobj;
41583 fail:
41584 return NULL;
41585 }
41586
41587
41588 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41589 PyObject *resultobj = 0;
41590 wxMenu *arg1 = (wxMenu *) 0 ;
41591 wxMenu *arg2 = (wxMenu *) 0 ;
41592 void *argp1 = 0 ;
41593 int res1 = 0 ;
41594 void *argp2 = 0 ;
41595 int res2 = 0 ;
41596 PyObject * obj0 = 0 ;
41597 PyObject * obj1 = 0 ;
41598 char * kwnames[] = {
41599 (char *) "self",(char *) "parent", NULL
41600 };
41601
41602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41604 if (!SWIG_IsOK(res1)) {
41605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41606 }
41607 arg1 = reinterpret_cast< wxMenu * >(argp1);
41608 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41609 if (!SWIG_IsOK(res2)) {
41610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41611 }
41612 arg2 = reinterpret_cast< wxMenu * >(argp2);
41613 {
41614 PyThreadState* __tstate = wxPyBeginAllowThreads();
41615 (arg1)->SetParent(arg2);
41616 wxPyEndAllowThreads(__tstate);
41617 if (PyErr_Occurred()) SWIG_fail;
41618 }
41619 resultobj = SWIG_Py_Void();
41620 return resultobj;
41621 fail:
41622 return NULL;
41623 }
41624
41625
41626 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41627 PyObject *resultobj = 0;
41628 wxMenu *arg1 = (wxMenu *) 0 ;
41629 wxMenu *result = 0 ;
41630 void *argp1 = 0 ;
41631 int res1 = 0 ;
41632 PyObject *swig_obj[1] ;
41633
41634 if (!args) SWIG_fail;
41635 swig_obj[0] = args;
41636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41637 if (!SWIG_IsOK(res1)) {
41638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41639 }
41640 arg1 = reinterpret_cast< wxMenu * >(argp1);
41641 {
41642 PyThreadState* __tstate = wxPyBeginAllowThreads();
41643 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41644 wxPyEndAllowThreads(__tstate);
41645 if (PyErr_Occurred()) SWIG_fail;
41646 }
41647 {
41648 resultobj = wxPyMake_wxObject(result, 0);
41649 }
41650 return resultobj;
41651 fail:
41652 return NULL;
41653 }
41654
41655
41656 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41657 PyObject *obj;
41658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41659 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41660 return SWIG_Py_Void();
41661 }
41662
41663 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41664 return SWIG_Python_InitShadowInstance(args);
41665 }
41666
41667 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41668 PyObject *resultobj = 0;
41669 long arg1 = (long) 0 ;
41670 wxMenuBar *result = 0 ;
41671 long val1 ;
41672 int ecode1 = 0 ;
41673 PyObject * obj0 = 0 ;
41674 char * kwnames[] = {
41675 (char *) "style", NULL
41676 };
41677
41678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41679 if (obj0) {
41680 ecode1 = SWIG_AsVal_long(obj0, &val1);
41681 if (!SWIG_IsOK(ecode1)) {
41682 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41683 }
41684 arg1 = static_cast< long >(val1);
41685 }
41686 {
41687 if (!wxPyCheckForApp()) SWIG_fail;
41688 PyThreadState* __tstate = wxPyBeginAllowThreads();
41689 result = (wxMenuBar *)new wxMenuBar(arg1);
41690 wxPyEndAllowThreads(__tstate);
41691 if (PyErr_Occurred()) SWIG_fail;
41692 }
41693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41694 return resultobj;
41695 fail:
41696 return NULL;
41697 }
41698
41699
41700 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41701 PyObject *resultobj = 0;
41702 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41703 wxMenu *arg2 = (wxMenu *) 0 ;
41704 wxString *arg3 = 0 ;
41705 bool result;
41706 void *argp1 = 0 ;
41707 int res1 = 0 ;
41708 void *argp2 = 0 ;
41709 int res2 = 0 ;
41710 bool temp3 = false ;
41711 PyObject * obj0 = 0 ;
41712 PyObject * obj1 = 0 ;
41713 PyObject * obj2 = 0 ;
41714 char * kwnames[] = {
41715 (char *) "self",(char *) "menu",(char *) "title", NULL
41716 };
41717
41718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41720 if (!SWIG_IsOK(res1)) {
41721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41722 }
41723 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41724 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41725 if (!SWIG_IsOK(res2)) {
41726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41727 }
41728 arg2 = reinterpret_cast< wxMenu * >(argp2);
41729 {
41730 arg3 = wxString_in_helper(obj2);
41731 if (arg3 == NULL) SWIG_fail;
41732 temp3 = true;
41733 }
41734 {
41735 PyThreadState* __tstate = wxPyBeginAllowThreads();
41736 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41737 wxPyEndAllowThreads(__tstate);
41738 if (PyErr_Occurred()) SWIG_fail;
41739 }
41740 {
41741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41742 }
41743 {
41744 if (temp3)
41745 delete arg3;
41746 }
41747 return resultobj;
41748 fail:
41749 {
41750 if (temp3)
41751 delete arg3;
41752 }
41753 return NULL;
41754 }
41755
41756
41757 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41758 PyObject *resultobj = 0;
41759 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41760 size_t arg2 ;
41761 wxMenu *arg3 = (wxMenu *) 0 ;
41762 wxString *arg4 = 0 ;
41763 bool result;
41764 void *argp1 = 0 ;
41765 int res1 = 0 ;
41766 size_t val2 ;
41767 int ecode2 = 0 ;
41768 void *argp3 = 0 ;
41769 int res3 = 0 ;
41770 bool temp4 = false ;
41771 PyObject * obj0 = 0 ;
41772 PyObject * obj1 = 0 ;
41773 PyObject * obj2 = 0 ;
41774 PyObject * obj3 = 0 ;
41775 char * kwnames[] = {
41776 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41777 };
41778
41779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41781 if (!SWIG_IsOK(res1)) {
41782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41783 }
41784 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41785 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41786 if (!SWIG_IsOK(ecode2)) {
41787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41788 }
41789 arg2 = static_cast< size_t >(val2);
41790 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41791 if (!SWIG_IsOK(res3)) {
41792 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41793 }
41794 arg3 = reinterpret_cast< wxMenu * >(argp3);
41795 {
41796 arg4 = wxString_in_helper(obj3);
41797 if (arg4 == NULL) SWIG_fail;
41798 temp4 = true;
41799 }
41800 {
41801 PyThreadState* __tstate = wxPyBeginAllowThreads();
41802 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41803 wxPyEndAllowThreads(__tstate);
41804 if (PyErr_Occurred()) SWIG_fail;
41805 }
41806 {
41807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41808 }
41809 {
41810 if (temp4)
41811 delete arg4;
41812 }
41813 return resultobj;
41814 fail:
41815 {
41816 if (temp4)
41817 delete arg4;
41818 }
41819 return NULL;
41820 }
41821
41822
41823 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41824 PyObject *resultobj = 0;
41825 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41826 size_t result;
41827 void *argp1 = 0 ;
41828 int res1 = 0 ;
41829 PyObject *swig_obj[1] ;
41830
41831 if (!args) SWIG_fail;
41832 swig_obj[0] = args;
41833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41834 if (!SWIG_IsOK(res1)) {
41835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41836 }
41837 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41838 {
41839 PyThreadState* __tstate = wxPyBeginAllowThreads();
41840 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41841 wxPyEndAllowThreads(__tstate);
41842 if (PyErr_Occurred()) SWIG_fail;
41843 }
41844 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41845 return resultobj;
41846 fail:
41847 return NULL;
41848 }
41849
41850
41851 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41852 PyObject *resultobj = 0;
41853 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41854 size_t arg2 ;
41855 wxMenu *result = 0 ;
41856 void *argp1 = 0 ;
41857 int res1 = 0 ;
41858 size_t val2 ;
41859 int ecode2 = 0 ;
41860 PyObject * obj0 = 0 ;
41861 PyObject * obj1 = 0 ;
41862 char * kwnames[] = {
41863 (char *) "self",(char *) "pos", NULL
41864 };
41865
41866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41868 if (!SWIG_IsOK(res1)) {
41869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41870 }
41871 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41872 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41873 if (!SWIG_IsOK(ecode2)) {
41874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41875 }
41876 arg2 = static_cast< size_t >(val2);
41877 {
41878 PyThreadState* __tstate = wxPyBeginAllowThreads();
41879 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41880 wxPyEndAllowThreads(__tstate);
41881 if (PyErr_Occurred()) SWIG_fail;
41882 }
41883 {
41884 resultobj = wxPyMake_wxObject(result, 0);
41885 }
41886 return resultobj;
41887 fail:
41888 return NULL;
41889 }
41890
41891
41892 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41893 PyObject *resultobj = 0;
41894 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41895 size_t arg2 ;
41896 wxMenu *arg3 = (wxMenu *) 0 ;
41897 wxString *arg4 = 0 ;
41898 wxMenu *result = 0 ;
41899 void *argp1 = 0 ;
41900 int res1 = 0 ;
41901 size_t val2 ;
41902 int ecode2 = 0 ;
41903 void *argp3 = 0 ;
41904 int res3 = 0 ;
41905 bool temp4 = false ;
41906 PyObject * obj0 = 0 ;
41907 PyObject * obj1 = 0 ;
41908 PyObject * obj2 = 0 ;
41909 PyObject * obj3 = 0 ;
41910 char * kwnames[] = {
41911 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41912 };
41913
41914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41916 if (!SWIG_IsOK(res1)) {
41917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41918 }
41919 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41920 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41921 if (!SWIG_IsOK(ecode2)) {
41922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41923 }
41924 arg2 = static_cast< size_t >(val2);
41925 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41926 if (!SWIG_IsOK(res3)) {
41927 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41928 }
41929 arg3 = reinterpret_cast< wxMenu * >(argp3);
41930 {
41931 arg4 = wxString_in_helper(obj3);
41932 if (arg4 == NULL) SWIG_fail;
41933 temp4 = true;
41934 }
41935 {
41936 PyThreadState* __tstate = wxPyBeginAllowThreads();
41937 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41938 wxPyEndAllowThreads(__tstate);
41939 if (PyErr_Occurred()) SWIG_fail;
41940 }
41941 {
41942 resultobj = wxPyMake_wxObject(result, 0);
41943 }
41944 {
41945 if (temp4)
41946 delete arg4;
41947 }
41948 return resultobj;
41949 fail:
41950 {
41951 if (temp4)
41952 delete arg4;
41953 }
41954 return NULL;
41955 }
41956
41957
41958 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41959 PyObject *resultobj = 0;
41960 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41961 size_t arg2 ;
41962 wxMenu *result = 0 ;
41963 void *argp1 = 0 ;
41964 int res1 = 0 ;
41965 size_t val2 ;
41966 int ecode2 = 0 ;
41967 PyObject * obj0 = 0 ;
41968 PyObject * obj1 = 0 ;
41969 char * kwnames[] = {
41970 (char *) "self",(char *) "pos", NULL
41971 };
41972
41973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41975 if (!SWIG_IsOK(res1)) {
41976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41977 }
41978 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41979 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41980 if (!SWIG_IsOK(ecode2)) {
41981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41982 }
41983 arg2 = static_cast< size_t >(val2);
41984 {
41985 PyThreadState* __tstate = wxPyBeginAllowThreads();
41986 result = (wxMenu *)(arg1)->Remove(arg2);
41987 wxPyEndAllowThreads(__tstate);
41988 if (PyErr_Occurred()) SWIG_fail;
41989 }
41990 {
41991 resultobj = wxPyMake_wxObject(result, 0);
41992 }
41993 return resultobj;
41994 fail:
41995 return NULL;
41996 }
41997
41998
41999 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42000 PyObject *resultobj = 0;
42001 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42002 size_t arg2 ;
42003 bool arg3 ;
42004 void *argp1 = 0 ;
42005 int res1 = 0 ;
42006 size_t val2 ;
42007 int ecode2 = 0 ;
42008 bool val3 ;
42009 int ecode3 = 0 ;
42010 PyObject * obj0 = 0 ;
42011 PyObject * obj1 = 0 ;
42012 PyObject * obj2 = 0 ;
42013 char * kwnames[] = {
42014 (char *) "self",(char *) "pos",(char *) "enable", NULL
42015 };
42016
42017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42019 if (!SWIG_IsOK(res1)) {
42020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42021 }
42022 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42023 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42024 if (!SWIG_IsOK(ecode2)) {
42025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42026 }
42027 arg2 = static_cast< size_t >(val2);
42028 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42029 if (!SWIG_IsOK(ecode3)) {
42030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42031 }
42032 arg3 = static_cast< bool >(val3);
42033 {
42034 PyThreadState* __tstate = wxPyBeginAllowThreads();
42035 (arg1)->EnableTop(arg2,arg3);
42036 wxPyEndAllowThreads(__tstate);
42037 if (PyErr_Occurred()) SWIG_fail;
42038 }
42039 resultobj = SWIG_Py_Void();
42040 return resultobj;
42041 fail:
42042 return NULL;
42043 }
42044
42045
42046 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42047 PyObject *resultobj = 0;
42048 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42049 size_t arg2 ;
42050 bool result;
42051 void *argp1 = 0 ;
42052 int res1 = 0 ;
42053 size_t val2 ;
42054 int ecode2 = 0 ;
42055 PyObject * obj0 = 0 ;
42056 PyObject * obj1 = 0 ;
42057 char * kwnames[] = {
42058 (char *) "self",(char *) "pos", NULL
42059 };
42060
42061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42063 if (!SWIG_IsOK(res1)) {
42064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42065 }
42066 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42067 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42068 if (!SWIG_IsOK(ecode2)) {
42069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42070 }
42071 arg2 = static_cast< size_t >(val2);
42072 {
42073 PyThreadState* __tstate = wxPyBeginAllowThreads();
42074 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42075 wxPyEndAllowThreads(__tstate);
42076 if (PyErr_Occurred()) SWIG_fail;
42077 }
42078 {
42079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42080 }
42081 return resultobj;
42082 fail:
42083 return NULL;
42084 }
42085
42086
42087 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42088 PyObject *resultobj = 0;
42089 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42090 size_t arg2 ;
42091 wxString *arg3 = 0 ;
42092 void *argp1 = 0 ;
42093 int res1 = 0 ;
42094 size_t val2 ;
42095 int ecode2 = 0 ;
42096 bool temp3 = false ;
42097 PyObject * obj0 = 0 ;
42098 PyObject * obj1 = 0 ;
42099 PyObject * obj2 = 0 ;
42100 char * kwnames[] = {
42101 (char *) "self",(char *) "pos",(char *) "label", NULL
42102 };
42103
42104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42106 if (!SWIG_IsOK(res1)) {
42107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42108 }
42109 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42110 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42111 if (!SWIG_IsOK(ecode2)) {
42112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42113 }
42114 arg2 = static_cast< size_t >(val2);
42115 {
42116 arg3 = wxString_in_helper(obj2);
42117 if (arg3 == NULL) SWIG_fail;
42118 temp3 = true;
42119 }
42120 {
42121 PyThreadState* __tstate = wxPyBeginAllowThreads();
42122 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42123 wxPyEndAllowThreads(__tstate);
42124 if (PyErr_Occurred()) SWIG_fail;
42125 }
42126 resultobj = SWIG_Py_Void();
42127 {
42128 if (temp3)
42129 delete arg3;
42130 }
42131 return resultobj;
42132 fail:
42133 {
42134 if (temp3)
42135 delete arg3;
42136 }
42137 return NULL;
42138 }
42139
42140
42141 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42142 PyObject *resultobj = 0;
42143 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42144 size_t arg2 ;
42145 wxString result;
42146 void *argp1 = 0 ;
42147 int res1 = 0 ;
42148 size_t val2 ;
42149 int ecode2 = 0 ;
42150 PyObject * obj0 = 0 ;
42151 PyObject * obj1 = 0 ;
42152 char * kwnames[] = {
42153 (char *) "self",(char *) "pos", NULL
42154 };
42155
42156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42158 if (!SWIG_IsOK(res1)) {
42159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42160 }
42161 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42162 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42163 if (!SWIG_IsOK(ecode2)) {
42164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42165 }
42166 arg2 = static_cast< size_t >(val2);
42167 {
42168 PyThreadState* __tstate = wxPyBeginAllowThreads();
42169 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42170 wxPyEndAllowThreads(__tstate);
42171 if (PyErr_Occurred()) SWIG_fail;
42172 }
42173 {
42174 #if wxUSE_UNICODE
42175 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42176 #else
42177 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42178 #endif
42179 }
42180 return resultobj;
42181 fail:
42182 return NULL;
42183 }
42184
42185
42186 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42187 PyObject *resultobj = 0;
42188 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42189 wxString *arg2 = 0 ;
42190 wxString *arg3 = 0 ;
42191 int result;
42192 void *argp1 = 0 ;
42193 int res1 = 0 ;
42194 bool temp2 = false ;
42195 bool temp3 = false ;
42196 PyObject * obj0 = 0 ;
42197 PyObject * obj1 = 0 ;
42198 PyObject * obj2 = 0 ;
42199 char * kwnames[] = {
42200 (char *) "self",(char *) "menu",(char *) "item", NULL
42201 };
42202
42203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42205 if (!SWIG_IsOK(res1)) {
42206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42207 }
42208 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42209 {
42210 arg2 = wxString_in_helper(obj1);
42211 if (arg2 == NULL) SWIG_fail;
42212 temp2 = true;
42213 }
42214 {
42215 arg3 = wxString_in_helper(obj2);
42216 if (arg3 == NULL) SWIG_fail;
42217 temp3 = true;
42218 }
42219 {
42220 PyThreadState* __tstate = wxPyBeginAllowThreads();
42221 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42222 wxPyEndAllowThreads(__tstate);
42223 if (PyErr_Occurred()) SWIG_fail;
42224 }
42225 resultobj = SWIG_From_int(static_cast< int >(result));
42226 {
42227 if (temp2)
42228 delete arg2;
42229 }
42230 {
42231 if (temp3)
42232 delete arg3;
42233 }
42234 return resultobj;
42235 fail:
42236 {
42237 if (temp2)
42238 delete arg2;
42239 }
42240 {
42241 if (temp3)
42242 delete arg3;
42243 }
42244 return NULL;
42245 }
42246
42247
42248 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42249 PyObject *resultobj = 0;
42250 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42251 int arg2 ;
42252 wxMenuItem *result = 0 ;
42253 void *argp1 = 0 ;
42254 int res1 = 0 ;
42255 int val2 ;
42256 int ecode2 = 0 ;
42257 PyObject * obj0 = 0 ;
42258 PyObject * obj1 = 0 ;
42259 char * kwnames[] = {
42260 (char *) "self",(char *) "id", NULL
42261 };
42262
42263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42265 if (!SWIG_IsOK(res1)) {
42266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42267 }
42268 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42269 ecode2 = SWIG_AsVal_int(obj1, &val2);
42270 if (!SWIG_IsOK(ecode2)) {
42271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42272 }
42273 arg2 = static_cast< int >(val2);
42274 {
42275 PyThreadState* __tstate = wxPyBeginAllowThreads();
42276 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42277 wxPyEndAllowThreads(__tstate);
42278 if (PyErr_Occurred()) SWIG_fail;
42279 }
42280 {
42281 resultobj = wxPyMake_wxObject(result, (bool)0);
42282 }
42283 return resultobj;
42284 fail:
42285 return NULL;
42286 }
42287
42288
42289 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42290 PyObject *resultobj = 0;
42291 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42292 wxString *arg2 = 0 ;
42293 int result;
42294 void *argp1 = 0 ;
42295 int res1 = 0 ;
42296 bool temp2 = false ;
42297 PyObject * obj0 = 0 ;
42298 PyObject * obj1 = 0 ;
42299 char * kwnames[] = {
42300 (char *) "self",(char *) "title", NULL
42301 };
42302
42303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42305 if (!SWIG_IsOK(res1)) {
42306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42307 }
42308 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42309 {
42310 arg2 = wxString_in_helper(obj1);
42311 if (arg2 == NULL) SWIG_fail;
42312 temp2 = true;
42313 }
42314 {
42315 PyThreadState* __tstate = wxPyBeginAllowThreads();
42316 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42317 wxPyEndAllowThreads(__tstate);
42318 if (PyErr_Occurred()) SWIG_fail;
42319 }
42320 resultobj = SWIG_From_int(static_cast< int >(result));
42321 {
42322 if (temp2)
42323 delete arg2;
42324 }
42325 return resultobj;
42326 fail:
42327 {
42328 if (temp2)
42329 delete arg2;
42330 }
42331 return NULL;
42332 }
42333
42334
42335 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42336 PyObject *resultobj = 0;
42337 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42338 int arg2 ;
42339 bool arg3 ;
42340 void *argp1 = 0 ;
42341 int res1 = 0 ;
42342 int val2 ;
42343 int ecode2 = 0 ;
42344 bool val3 ;
42345 int ecode3 = 0 ;
42346 PyObject * obj0 = 0 ;
42347 PyObject * obj1 = 0 ;
42348 PyObject * obj2 = 0 ;
42349 char * kwnames[] = {
42350 (char *) "self",(char *) "id",(char *) "enable", NULL
42351 };
42352
42353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42355 if (!SWIG_IsOK(res1)) {
42356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42357 }
42358 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42359 ecode2 = SWIG_AsVal_int(obj1, &val2);
42360 if (!SWIG_IsOK(ecode2)) {
42361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42362 }
42363 arg2 = static_cast< int >(val2);
42364 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42365 if (!SWIG_IsOK(ecode3)) {
42366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42367 }
42368 arg3 = static_cast< bool >(val3);
42369 {
42370 PyThreadState* __tstate = wxPyBeginAllowThreads();
42371 (arg1)->Enable(arg2,arg3);
42372 wxPyEndAllowThreads(__tstate);
42373 if (PyErr_Occurred()) SWIG_fail;
42374 }
42375 resultobj = SWIG_Py_Void();
42376 return resultobj;
42377 fail:
42378 return NULL;
42379 }
42380
42381
42382 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42383 PyObject *resultobj = 0;
42384 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42385 int arg2 ;
42386 bool arg3 ;
42387 void *argp1 = 0 ;
42388 int res1 = 0 ;
42389 int val2 ;
42390 int ecode2 = 0 ;
42391 bool val3 ;
42392 int ecode3 = 0 ;
42393 PyObject * obj0 = 0 ;
42394 PyObject * obj1 = 0 ;
42395 PyObject * obj2 = 0 ;
42396 char * kwnames[] = {
42397 (char *) "self",(char *) "id",(char *) "check", NULL
42398 };
42399
42400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42402 if (!SWIG_IsOK(res1)) {
42403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42404 }
42405 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42406 ecode2 = SWIG_AsVal_int(obj1, &val2);
42407 if (!SWIG_IsOK(ecode2)) {
42408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42409 }
42410 arg2 = static_cast< int >(val2);
42411 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42412 if (!SWIG_IsOK(ecode3)) {
42413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42414 }
42415 arg3 = static_cast< bool >(val3);
42416 {
42417 PyThreadState* __tstate = wxPyBeginAllowThreads();
42418 (arg1)->Check(arg2,arg3);
42419 wxPyEndAllowThreads(__tstate);
42420 if (PyErr_Occurred()) SWIG_fail;
42421 }
42422 resultobj = SWIG_Py_Void();
42423 return resultobj;
42424 fail:
42425 return NULL;
42426 }
42427
42428
42429 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42430 PyObject *resultobj = 0;
42431 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42432 int arg2 ;
42433 bool result;
42434 void *argp1 = 0 ;
42435 int res1 = 0 ;
42436 int val2 ;
42437 int ecode2 = 0 ;
42438 PyObject * obj0 = 0 ;
42439 PyObject * obj1 = 0 ;
42440 char * kwnames[] = {
42441 (char *) "self",(char *) "id", NULL
42442 };
42443
42444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42446 if (!SWIG_IsOK(res1)) {
42447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42448 }
42449 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42450 ecode2 = SWIG_AsVal_int(obj1, &val2);
42451 if (!SWIG_IsOK(ecode2)) {
42452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42453 }
42454 arg2 = static_cast< int >(val2);
42455 {
42456 PyThreadState* __tstate = wxPyBeginAllowThreads();
42457 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42458 wxPyEndAllowThreads(__tstate);
42459 if (PyErr_Occurred()) SWIG_fail;
42460 }
42461 {
42462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42463 }
42464 return resultobj;
42465 fail:
42466 return NULL;
42467 }
42468
42469
42470 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42471 PyObject *resultobj = 0;
42472 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42473 int arg2 ;
42474 bool result;
42475 void *argp1 = 0 ;
42476 int res1 = 0 ;
42477 int val2 ;
42478 int ecode2 = 0 ;
42479 PyObject * obj0 = 0 ;
42480 PyObject * obj1 = 0 ;
42481 char * kwnames[] = {
42482 (char *) "self",(char *) "id", NULL
42483 };
42484
42485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42487 if (!SWIG_IsOK(res1)) {
42488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42489 }
42490 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42491 ecode2 = SWIG_AsVal_int(obj1, &val2);
42492 if (!SWIG_IsOK(ecode2)) {
42493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42494 }
42495 arg2 = static_cast< int >(val2);
42496 {
42497 PyThreadState* __tstate = wxPyBeginAllowThreads();
42498 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42499 wxPyEndAllowThreads(__tstate);
42500 if (PyErr_Occurred()) SWIG_fail;
42501 }
42502 {
42503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42504 }
42505 return resultobj;
42506 fail:
42507 return NULL;
42508 }
42509
42510
42511 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42512 PyObject *resultobj = 0;
42513 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42514 int arg2 ;
42515 wxString *arg3 = 0 ;
42516 void *argp1 = 0 ;
42517 int res1 = 0 ;
42518 int val2 ;
42519 int ecode2 = 0 ;
42520 bool temp3 = false ;
42521 PyObject * obj0 = 0 ;
42522 PyObject * obj1 = 0 ;
42523 PyObject * obj2 = 0 ;
42524 char * kwnames[] = {
42525 (char *) "self",(char *) "id",(char *) "label", NULL
42526 };
42527
42528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42530 if (!SWIG_IsOK(res1)) {
42531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42532 }
42533 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42534 ecode2 = SWIG_AsVal_int(obj1, &val2);
42535 if (!SWIG_IsOK(ecode2)) {
42536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42537 }
42538 arg2 = static_cast< int >(val2);
42539 {
42540 arg3 = wxString_in_helper(obj2);
42541 if (arg3 == NULL) SWIG_fail;
42542 temp3 = true;
42543 }
42544 {
42545 PyThreadState* __tstate = wxPyBeginAllowThreads();
42546 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42547 wxPyEndAllowThreads(__tstate);
42548 if (PyErr_Occurred()) SWIG_fail;
42549 }
42550 resultobj = SWIG_Py_Void();
42551 {
42552 if (temp3)
42553 delete arg3;
42554 }
42555 return resultobj;
42556 fail:
42557 {
42558 if (temp3)
42559 delete arg3;
42560 }
42561 return NULL;
42562 }
42563
42564
42565 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42566 PyObject *resultobj = 0;
42567 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42568 int arg2 ;
42569 wxString result;
42570 void *argp1 = 0 ;
42571 int res1 = 0 ;
42572 int val2 ;
42573 int ecode2 = 0 ;
42574 PyObject * obj0 = 0 ;
42575 PyObject * obj1 = 0 ;
42576 char * kwnames[] = {
42577 (char *) "self",(char *) "id", NULL
42578 };
42579
42580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42582 if (!SWIG_IsOK(res1)) {
42583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42584 }
42585 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42586 ecode2 = SWIG_AsVal_int(obj1, &val2);
42587 if (!SWIG_IsOK(ecode2)) {
42588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42589 }
42590 arg2 = static_cast< int >(val2);
42591 {
42592 PyThreadState* __tstate = wxPyBeginAllowThreads();
42593 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42594 wxPyEndAllowThreads(__tstate);
42595 if (PyErr_Occurred()) SWIG_fail;
42596 }
42597 {
42598 #if wxUSE_UNICODE
42599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42600 #else
42601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42602 #endif
42603 }
42604 return resultobj;
42605 fail:
42606 return NULL;
42607 }
42608
42609
42610 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42611 PyObject *resultobj = 0;
42612 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42613 int arg2 ;
42614 wxString *arg3 = 0 ;
42615 void *argp1 = 0 ;
42616 int res1 = 0 ;
42617 int val2 ;
42618 int ecode2 = 0 ;
42619 bool temp3 = false ;
42620 PyObject * obj0 = 0 ;
42621 PyObject * obj1 = 0 ;
42622 PyObject * obj2 = 0 ;
42623 char * kwnames[] = {
42624 (char *) "self",(char *) "id",(char *) "helpString", NULL
42625 };
42626
42627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42629 if (!SWIG_IsOK(res1)) {
42630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42631 }
42632 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42633 ecode2 = SWIG_AsVal_int(obj1, &val2);
42634 if (!SWIG_IsOK(ecode2)) {
42635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42636 }
42637 arg2 = static_cast< int >(val2);
42638 {
42639 arg3 = wxString_in_helper(obj2);
42640 if (arg3 == NULL) SWIG_fail;
42641 temp3 = true;
42642 }
42643 {
42644 PyThreadState* __tstate = wxPyBeginAllowThreads();
42645 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42646 wxPyEndAllowThreads(__tstate);
42647 if (PyErr_Occurred()) SWIG_fail;
42648 }
42649 resultobj = SWIG_Py_Void();
42650 {
42651 if (temp3)
42652 delete arg3;
42653 }
42654 return resultobj;
42655 fail:
42656 {
42657 if (temp3)
42658 delete arg3;
42659 }
42660 return NULL;
42661 }
42662
42663
42664 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42665 PyObject *resultobj = 0;
42666 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42667 int arg2 ;
42668 wxString result;
42669 void *argp1 = 0 ;
42670 int res1 = 0 ;
42671 int val2 ;
42672 int ecode2 = 0 ;
42673 PyObject * obj0 = 0 ;
42674 PyObject * obj1 = 0 ;
42675 char * kwnames[] = {
42676 (char *) "self",(char *) "id", NULL
42677 };
42678
42679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42681 if (!SWIG_IsOK(res1)) {
42682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42683 }
42684 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42685 ecode2 = SWIG_AsVal_int(obj1, &val2);
42686 if (!SWIG_IsOK(ecode2)) {
42687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42688 }
42689 arg2 = static_cast< int >(val2);
42690 {
42691 PyThreadState* __tstate = wxPyBeginAllowThreads();
42692 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42693 wxPyEndAllowThreads(__tstate);
42694 if (PyErr_Occurred()) SWIG_fail;
42695 }
42696 {
42697 #if wxUSE_UNICODE
42698 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42699 #else
42700 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42701 #endif
42702 }
42703 return resultobj;
42704 fail:
42705 return NULL;
42706 }
42707
42708
42709 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42710 PyObject *resultobj = 0;
42711 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42712 wxFrame *result = 0 ;
42713 void *argp1 = 0 ;
42714 int res1 = 0 ;
42715 PyObject *swig_obj[1] ;
42716
42717 if (!args) SWIG_fail;
42718 swig_obj[0] = args;
42719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42720 if (!SWIG_IsOK(res1)) {
42721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42722 }
42723 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42724 {
42725 PyThreadState* __tstate = wxPyBeginAllowThreads();
42726 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42727 wxPyEndAllowThreads(__tstate);
42728 if (PyErr_Occurred()) SWIG_fail;
42729 }
42730 {
42731 resultobj = wxPyMake_wxObject(result, (bool)0);
42732 }
42733 return resultobj;
42734 fail:
42735 return NULL;
42736 }
42737
42738
42739 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42740 PyObject *resultobj = 0;
42741 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42742 bool result;
42743 void *argp1 = 0 ;
42744 int res1 = 0 ;
42745 PyObject *swig_obj[1] ;
42746
42747 if (!args) SWIG_fail;
42748 swig_obj[0] = args;
42749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42750 if (!SWIG_IsOK(res1)) {
42751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42752 }
42753 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42754 {
42755 PyThreadState* __tstate = wxPyBeginAllowThreads();
42756 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42757 wxPyEndAllowThreads(__tstate);
42758 if (PyErr_Occurred()) SWIG_fail;
42759 }
42760 {
42761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42762 }
42763 return resultobj;
42764 fail:
42765 return NULL;
42766 }
42767
42768
42769 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42770 PyObject *resultobj = 0;
42771 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42772 wxFrame *arg2 = (wxFrame *) 0 ;
42773 void *argp1 = 0 ;
42774 int res1 = 0 ;
42775 void *argp2 = 0 ;
42776 int res2 = 0 ;
42777 PyObject * obj0 = 0 ;
42778 PyObject * obj1 = 0 ;
42779 char * kwnames[] = {
42780 (char *) "self",(char *) "frame", NULL
42781 };
42782
42783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42785 if (!SWIG_IsOK(res1)) {
42786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42787 }
42788 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42789 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42790 if (!SWIG_IsOK(res2)) {
42791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42792 }
42793 arg2 = reinterpret_cast< wxFrame * >(argp2);
42794 {
42795 PyThreadState* __tstate = wxPyBeginAllowThreads();
42796 (arg1)->Attach(arg2);
42797 wxPyEndAllowThreads(__tstate);
42798 if (PyErr_Occurred()) SWIG_fail;
42799 }
42800 resultobj = SWIG_Py_Void();
42801 return resultobj;
42802 fail:
42803 return NULL;
42804 }
42805
42806
42807 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42808 PyObject *resultobj = 0;
42809 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42810 void *argp1 = 0 ;
42811 int res1 = 0 ;
42812 PyObject *swig_obj[1] ;
42813
42814 if (!args) SWIG_fail;
42815 swig_obj[0] = args;
42816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42817 if (!SWIG_IsOK(res1)) {
42818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42819 }
42820 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42821 {
42822 PyThreadState* __tstate = wxPyBeginAllowThreads();
42823 (arg1)->Detach();
42824 wxPyEndAllowThreads(__tstate);
42825 if (PyErr_Occurred()) SWIG_fail;
42826 }
42827 resultobj = SWIG_Py_Void();
42828 return resultobj;
42829 fail:
42830 return NULL;
42831 }
42832
42833
42834 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42835 PyObject *resultobj = 0;
42836 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42837 void *argp1 = 0 ;
42838 int res1 = 0 ;
42839 PyObject *swig_obj[1] ;
42840
42841 if (!args) SWIG_fail;
42842 swig_obj[0] = args;
42843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42844 if (!SWIG_IsOK(res1)) {
42845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42846 }
42847 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42848 {
42849 PyThreadState* __tstate = wxPyBeginAllowThreads();
42850 (arg1)->UpdateMenus();
42851 wxPyEndAllowThreads(__tstate);
42852 if (PyErr_Occurred()) SWIG_fail;
42853 }
42854 resultobj = SWIG_Py_Void();
42855 return resultobj;
42856 fail:
42857 return NULL;
42858 }
42859
42860
42861 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42862 PyObject *resultobj = 0;
42863 bool arg1 ;
42864 bool val1 ;
42865 int ecode1 = 0 ;
42866 PyObject * obj0 = 0 ;
42867 char * kwnames[] = {
42868 (char *) "enable", NULL
42869 };
42870
42871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42872 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42873 if (!SWIG_IsOK(ecode1)) {
42874 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42875 }
42876 arg1 = static_cast< bool >(val1);
42877 {
42878 PyThreadState* __tstate = wxPyBeginAllowThreads();
42879 wxMenuBar_SetAutoWindowMenu(arg1);
42880 wxPyEndAllowThreads(__tstate);
42881 if (PyErr_Occurred()) SWIG_fail;
42882 }
42883 resultobj = SWIG_Py_Void();
42884 return resultobj;
42885 fail:
42886 return NULL;
42887 }
42888
42889
42890 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42891 PyObject *resultobj = 0;
42892 bool result;
42893
42894 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42895 {
42896 PyThreadState* __tstate = wxPyBeginAllowThreads();
42897 result = (bool)wxMenuBar_GetAutoWindowMenu();
42898 wxPyEndAllowThreads(__tstate);
42899 if (PyErr_Occurred()) SWIG_fail;
42900 }
42901 {
42902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42903 }
42904 return resultobj;
42905 fail:
42906 return NULL;
42907 }
42908
42909
42910 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42911 PyObject *obj;
42912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42913 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42914 return SWIG_Py_Void();
42915 }
42916
42917 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42918 return SWIG_Python_InitShadowInstance(args);
42919 }
42920
42921 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42922 PyObject *resultobj = 0;
42923 wxMenu *arg1 = (wxMenu *) NULL ;
42924 int arg2 = (int) wxID_ANY ;
42925 wxString const &arg3_defvalue = wxPyEmptyString ;
42926 wxString *arg3 = (wxString *) &arg3_defvalue ;
42927 wxString const &arg4_defvalue = wxPyEmptyString ;
42928 wxString *arg4 = (wxString *) &arg4_defvalue ;
42929 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42930 wxMenu *arg6 = (wxMenu *) NULL ;
42931 wxMenuItem *result = 0 ;
42932 void *argp1 = 0 ;
42933 int res1 = 0 ;
42934 int val2 ;
42935 int ecode2 = 0 ;
42936 bool temp3 = false ;
42937 bool temp4 = false ;
42938 int val5 ;
42939 int ecode5 = 0 ;
42940 void *argp6 = 0 ;
42941 int res6 = 0 ;
42942 PyObject * obj0 = 0 ;
42943 PyObject * obj1 = 0 ;
42944 PyObject * obj2 = 0 ;
42945 PyObject * obj3 = 0 ;
42946 PyObject * obj4 = 0 ;
42947 PyObject * obj5 = 0 ;
42948 char * kwnames[] = {
42949 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42950 };
42951
42952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42953 if (obj0) {
42954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42955 if (!SWIG_IsOK(res1)) {
42956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42957 }
42958 arg1 = reinterpret_cast< wxMenu * >(argp1);
42959 }
42960 if (obj1) {
42961 ecode2 = SWIG_AsVal_int(obj1, &val2);
42962 if (!SWIG_IsOK(ecode2)) {
42963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42964 }
42965 arg2 = static_cast< int >(val2);
42966 }
42967 if (obj2) {
42968 {
42969 arg3 = wxString_in_helper(obj2);
42970 if (arg3 == NULL) SWIG_fail;
42971 temp3 = true;
42972 }
42973 }
42974 if (obj3) {
42975 {
42976 arg4 = wxString_in_helper(obj3);
42977 if (arg4 == NULL) SWIG_fail;
42978 temp4 = true;
42979 }
42980 }
42981 if (obj4) {
42982 ecode5 = SWIG_AsVal_int(obj4, &val5);
42983 if (!SWIG_IsOK(ecode5)) {
42984 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42985 }
42986 arg5 = static_cast< wxItemKind >(val5);
42987 }
42988 if (obj5) {
42989 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42990 if (!SWIG_IsOK(res6)) {
42991 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42992 }
42993 arg6 = reinterpret_cast< wxMenu * >(argp6);
42994 }
42995 {
42996 PyThreadState* __tstate = wxPyBeginAllowThreads();
42997 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42998 wxPyEndAllowThreads(__tstate);
42999 if (PyErr_Occurred()) SWIG_fail;
43000 }
43001 {
43002 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
43003 }
43004 {
43005 if (temp3)
43006 delete arg3;
43007 }
43008 {
43009 if (temp4)
43010 delete arg4;
43011 }
43012 return resultobj;
43013 fail:
43014 {
43015 if (temp3)
43016 delete arg3;
43017 }
43018 {
43019 if (temp4)
43020 delete arg4;
43021 }
43022 return NULL;
43023 }
43024
43025
43026 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43027 PyObject *resultobj = 0;
43028 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43029 void *argp1 = 0 ;
43030 int res1 = 0 ;
43031 PyObject *swig_obj[1] ;
43032
43033 if (!args) SWIG_fail;
43034 swig_obj[0] = args;
43035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43036 if (!SWIG_IsOK(res1)) {
43037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43038 }
43039 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43040 {
43041 PyThreadState* __tstate = wxPyBeginAllowThreads();
43042 delete arg1;
43043
43044 wxPyEndAllowThreads(__tstate);
43045 if (PyErr_Occurred()) SWIG_fail;
43046 }
43047 resultobj = SWIG_Py_Void();
43048 return resultobj;
43049 fail:
43050 return NULL;
43051 }
43052
43053
43054 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43055 PyObject *resultobj = 0;
43056 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43057 wxMenu *result = 0 ;
43058 void *argp1 = 0 ;
43059 int res1 = 0 ;
43060 PyObject *swig_obj[1] ;
43061
43062 if (!args) SWIG_fail;
43063 swig_obj[0] = args;
43064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43065 if (!SWIG_IsOK(res1)) {
43066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43067 }
43068 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43069 {
43070 PyThreadState* __tstate = wxPyBeginAllowThreads();
43071 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43072 wxPyEndAllowThreads(__tstate);
43073 if (PyErr_Occurred()) SWIG_fail;
43074 }
43075 {
43076 resultobj = wxPyMake_wxObject(result, 0);
43077 }
43078 return resultobj;
43079 fail:
43080 return NULL;
43081 }
43082
43083
43084 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43085 PyObject *resultobj = 0;
43086 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43087 wxMenu *arg2 = (wxMenu *) 0 ;
43088 void *argp1 = 0 ;
43089 int res1 = 0 ;
43090 void *argp2 = 0 ;
43091 int res2 = 0 ;
43092 PyObject * obj0 = 0 ;
43093 PyObject * obj1 = 0 ;
43094 char * kwnames[] = {
43095 (char *) "self",(char *) "menu", NULL
43096 };
43097
43098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43100 if (!SWIG_IsOK(res1)) {
43101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43102 }
43103 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43104 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43105 if (!SWIG_IsOK(res2)) {
43106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43107 }
43108 arg2 = reinterpret_cast< wxMenu * >(argp2);
43109 {
43110 PyThreadState* __tstate = wxPyBeginAllowThreads();
43111 (arg1)->SetMenu(arg2);
43112 wxPyEndAllowThreads(__tstate);
43113 if (PyErr_Occurred()) SWIG_fail;
43114 }
43115 resultobj = SWIG_Py_Void();
43116 return resultobj;
43117 fail:
43118 return NULL;
43119 }
43120
43121
43122 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43123 PyObject *resultobj = 0;
43124 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43125 int arg2 ;
43126 void *argp1 = 0 ;
43127 int res1 = 0 ;
43128 int val2 ;
43129 int ecode2 = 0 ;
43130 PyObject * obj0 = 0 ;
43131 PyObject * obj1 = 0 ;
43132 char * kwnames[] = {
43133 (char *) "self",(char *) "id", NULL
43134 };
43135
43136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43138 if (!SWIG_IsOK(res1)) {
43139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43140 }
43141 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43142 ecode2 = SWIG_AsVal_int(obj1, &val2);
43143 if (!SWIG_IsOK(ecode2)) {
43144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43145 }
43146 arg2 = static_cast< int >(val2);
43147 {
43148 PyThreadState* __tstate = wxPyBeginAllowThreads();
43149 (arg1)->SetId(arg2);
43150 wxPyEndAllowThreads(__tstate);
43151 if (PyErr_Occurred()) SWIG_fail;
43152 }
43153 resultobj = SWIG_Py_Void();
43154 return resultobj;
43155 fail:
43156 return NULL;
43157 }
43158
43159
43160 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43161 PyObject *resultobj = 0;
43162 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43163 int result;
43164 void *argp1 = 0 ;
43165 int res1 = 0 ;
43166 PyObject *swig_obj[1] ;
43167
43168 if (!args) SWIG_fail;
43169 swig_obj[0] = args;
43170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43171 if (!SWIG_IsOK(res1)) {
43172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43173 }
43174 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43175 {
43176 PyThreadState* __tstate = wxPyBeginAllowThreads();
43177 result = (int)((wxMenuItem const *)arg1)->GetId();
43178 wxPyEndAllowThreads(__tstate);
43179 if (PyErr_Occurred()) SWIG_fail;
43180 }
43181 resultobj = SWIG_From_int(static_cast< int >(result));
43182 return resultobj;
43183 fail:
43184 return NULL;
43185 }
43186
43187
43188 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43189 PyObject *resultobj = 0;
43190 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43191 bool result;
43192 void *argp1 = 0 ;
43193 int res1 = 0 ;
43194 PyObject *swig_obj[1] ;
43195
43196 if (!args) SWIG_fail;
43197 swig_obj[0] = args;
43198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43199 if (!SWIG_IsOK(res1)) {
43200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43201 }
43202 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43203 {
43204 PyThreadState* __tstate = wxPyBeginAllowThreads();
43205 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43206 wxPyEndAllowThreads(__tstate);
43207 if (PyErr_Occurred()) SWIG_fail;
43208 }
43209 {
43210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43211 }
43212 return resultobj;
43213 fail:
43214 return NULL;
43215 }
43216
43217
43218 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43219 PyObject *resultobj = 0;
43220 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43221 wxString *arg2 = 0 ;
43222 void *argp1 = 0 ;
43223 int res1 = 0 ;
43224 bool temp2 = false ;
43225 PyObject * obj0 = 0 ;
43226 PyObject * obj1 = 0 ;
43227 char * kwnames[] = {
43228 (char *) "self",(char *) "str", NULL
43229 };
43230
43231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43233 if (!SWIG_IsOK(res1)) {
43234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43235 }
43236 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43237 {
43238 arg2 = wxString_in_helper(obj1);
43239 if (arg2 == NULL) SWIG_fail;
43240 temp2 = true;
43241 }
43242 {
43243 PyThreadState* __tstate = wxPyBeginAllowThreads();
43244 (arg1)->SetText((wxString const &)*arg2);
43245 wxPyEndAllowThreads(__tstate);
43246 if (PyErr_Occurred()) SWIG_fail;
43247 }
43248 resultobj = SWIG_Py_Void();
43249 {
43250 if (temp2)
43251 delete arg2;
43252 }
43253 return resultobj;
43254 fail:
43255 {
43256 if (temp2)
43257 delete arg2;
43258 }
43259 return NULL;
43260 }
43261
43262
43263 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43264 PyObject *resultobj = 0;
43265 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43266 wxString result;
43267 void *argp1 = 0 ;
43268 int res1 = 0 ;
43269 PyObject *swig_obj[1] ;
43270
43271 if (!args) SWIG_fail;
43272 swig_obj[0] = args;
43273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43274 if (!SWIG_IsOK(res1)) {
43275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43276 }
43277 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43278 {
43279 PyThreadState* __tstate = wxPyBeginAllowThreads();
43280 result = ((wxMenuItem const *)arg1)->GetLabel();
43281 wxPyEndAllowThreads(__tstate);
43282 if (PyErr_Occurred()) SWIG_fail;
43283 }
43284 {
43285 #if wxUSE_UNICODE
43286 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43287 #else
43288 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43289 #endif
43290 }
43291 return resultobj;
43292 fail:
43293 return NULL;
43294 }
43295
43296
43297 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43298 PyObject *resultobj = 0;
43299 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43300 wxString *result = 0 ;
43301 void *argp1 = 0 ;
43302 int res1 = 0 ;
43303 PyObject *swig_obj[1] ;
43304
43305 if (!args) SWIG_fail;
43306 swig_obj[0] = args;
43307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43308 if (!SWIG_IsOK(res1)) {
43309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43310 }
43311 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43312 {
43313 PyThreadState* __tstate = wxPyBeginAllowThreads();
43314 {
43315 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43316 result = (wxString *) &_result_ref;
43317 }
43318 wxPyEndAllowThreads(__tstate);
43319 if (PyErr_Occurred()) SWIG_fail;
43320 }
43321 {
43322 #if wxUSE_UNICODE
43323 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43324 #else
43325 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43326 #endif
43327 }
43328 return resultobj;
43329 fail:
43330 return NULL;
43331 }
43332
43333
43334 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43335 PyObject *resultobj = 0;
43336 wxString *arg1 = 0 ;
43337 wxString result;
43338 bool temp1 = false ;
43339 PyObject * obj0 = 0 ;
43340 char * kwnames[] = {
43341 (char *) "text", NULL
43342 };
43343
43344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43345 {
43346 arg1 = wxString_in_helper(obj0);
43347 if (arg1 == NULL) SWIG_fail;
43348 temp1 = true;
43349 }
43350 {
43351 PyThreadState* __tstate = wxPyBeginAllowThreads();
43352 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43353 wxPyEndAllowThreads(__tstate);
43354 if (PyErr_Occurred()) SWIG_fail;
43355 }
43356 {
43357 #if wxUSE_UNICODE
43358 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43359 #else
43360 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43361 #endif
43362 }
43363 {
43364 if (temp1)
43365 delete arg1;
43366 }
43367 return resultobj;
43368 fail:
43369 {
43370 if (temp1)
43371 delete arg1;
43372 }
43373 return NULL;
43374 }
43375
43376
43377 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43378 PyObject *resultobj = 0;
43379 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43380 wxItemKind result;
43381 void *argp1 = 0 ;
43382 int res1 = 0 ;
43383 PyObject *swig_obj[1] ;
43384
43385 if (!args) SWIG_fail;
43386 swig_obj[0] = args;
43387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43388 if (!SWIG_IsOK(res1)) {
43389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43390 }
43391 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43392 {
43393 PyThreadState* __tstate = wxPyBeginAllowThreads();
43394 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43395 wxPyEndAllowThreads(__tstate);
43396 if (PyErr_Occurred()) SWIG_fail;
43397 }
43398 resultobj = SWIG_From_int(static_cast< int >(result));
43399 return resultobj;
43400 fail:
43401 return NULL;
43402 }
43403
43404
43405 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43406 PyObject *resultobj = 0;
43407 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43408 wxItemKind arg2 ;
43409 void *argp1 = 0 ;
43410 int res1 = 0 ;
43411 int val2 ;
43412 int ecode2 = 0 ;
43413 PyObject * obj0 = 0 ;
43414 PyObject * obj1 = 0 ;
43415 char * kwnames[] = {
43416 (char *) "self",(char *) "kind", NULL
43417 };
43418
43419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43421 if (!SWIG_IsOK(res1)) {
43422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43423 }
43424 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43425 ecode2 = SWIG_AsVal_int(obj1, &val2);
43426 if (!SWIG_IsOK(ecode2)) {
43427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43428 }
43429 arg2 = static_cast< wxItemKind >(val2);
43430 {
43431 PyThreadState* __tstate = wxPyBeginAllowThreads();
43432 (arg1)->SetKind(arg2);
43433 wxPyEndAllowThreads(__tstate);
43434 if (PyErr_Occurred()) SWIG_fail;
43435 }
43436 resultobj = SWIG_Py_Void();
43437 return resultobj;
43438 fail:
43439 return NULL;
43440 }
43441
43442
43443 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43444 PyObject *resultobj = 0;
43445 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43446 bool arg2 ;
43447 void *argp1 = 0 ;
43448 int res1 = 0 ;
43449 bool val2 ;
43450 int ecode2 = 0 ;
43451 PyObject * obj0 = 0 ;
43452 PyObject * obj1 = 0 ;
43453 char * kwnames[] = {
43454 (char *) "self",(char *) "checkable", NULL
43455 };
43456
43457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43459 if (!SWIG_IsOK(res1)) {
43460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43461 }
43462 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43463 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43464 if (!SWIG_IsOK(ecode2)) {
43465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43466 }
43467 arg2 = static_cast< bool >(val2);
43468 {
43469 PyThreadState* __tstate = wxPyBeginAllowThreads();
43470 (arg1)->SetCheckable(arg2);
43471 wxPyEndAllowThreads(__tstate);
43472 if (PyErr_Occurred()) SWIG_fail;
43473 }
43474 resultobj = SWIG_Py_Void();
43475 return resultobj;
43476 fail:
43477 return NULL;
43478 }
43479
43480
43481 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43482 PyObject *resultobj = 0;
43483 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43484 bool result;
43485 void *argp1 = 0 ;
43486 int res1 = 0 ;
43487 PyObject *swig_obj[1] ;
43488
43489 if (!args) SWIG_fail;
43490 swig_obj[0] = args;
43491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43492 if (!SWIG_IsOK(res1)) {
43493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43494 }
43495 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43496 {
43497 PyThreadState* __tstate = wxPyBeginAllowThreads();
43498 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43499 wxPyEndAllowThreads(__tstate);
43500 if (PyErr_Occurred()) SWIG_fail;
43501 }
43502 {
43503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43504 }
43505 return resultobj;
43506 fail:
43507 return NULL;
43508 }
43509
43510
43511 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43512 PyObject *resultobj = 0;
43513 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43514 bool result;
43515 void *argp1 = 0 ;
43516 int res1 = 0 ;
43517 PyObject *swig_obj[1] ;
43518
43519 if (!args) SWIG_fail;
43520 swig_obj[0] = args;
43521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43522 if (!SWIG_IsOK(res1)) {
43523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43524 }
43525 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43526 {
43527 PyThreadState* __tstate = wxPyBeginAllowThreads();
43528 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43529 wxPyEndAllowThreads(__tstate);
43530 if (PyErr_Occurred()) SWIG_fail;
43531 }
43532 {
43533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43534 }
43535 return resultobj;
43536 fail:
43537 return NULL;
43538 }
43539
43540
43541 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43542 PyObject *resultobj = 0;
43543 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43544 wxMenu *arg2 = (wxMenu *) 0 ;
43545 void *argp1 = 0 ;
43546 int res1 = 0 ;
43547 void *argp2 = 0 ;
43548 int res2 = 0 ;
43549 PyObject * obj0 = 0 ;
43550 PyObject * obj1 = 0 ;
43551 char * kwnames[] = {
43552 (char *) "self",(char *) "menu", NULL
43553 };
43554
43555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43557 if (!SWIG_IsOK(res1)) {
43558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43559 }
43560 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43561 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43562 if (!SWIG_IsOK(res2)) {
43563 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43564 }
43565 arg2 = reinterpret_cast< wxMenu * >(argp2);
43566 {
43567 PyThreadState* __tstate = wxPyBeginAllowThreads();
43568 (arg1)->SetSubMenu(arg2);
43569 wxPyEndAllowThreads(__tstate);
43570 if (PyErr_Occurred()) SWIG_fail;
43571 }
43572 resultobj = SWIG_Py_Void();
43573 return resultobj;
43574 fail:
43575 return NULL;
43576 }
43577
43578
43579 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43580 PyObject *resultobj = 0;
43581 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43582 wxMenu *result = 0 ;
43583 void *argp1 = 0 ;
43584 int res1 = 0 ;
43585 PyObject *swig_obj[1] ;
43586
43587 if (!args) SWIG_fail;
43588 swig_obj[0] = args;
43589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43590 if (!SWIG_IsOK(res1)) {
43591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43592 }
43593 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43594 {
43595 PyThreadState* __tstate = wxPyBeginAllowThreads();
43596 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43597 wxPyEndAllowThreads(__tstate);
43598 if (PyErr_Occurred()) SWIG_fail;
43599 }
43600 {
43601 resultobj = wxPyMake_wxObject(result, 0);
43602 }
43603 return resultobj;
43604 fail:
43605 return NULL;
43606 }
43607
43608
43609 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43610 PyObject *resultobj = 0;
43611 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43612 bool arg2 = (bool) true ;
43613 void *argp1 = 0 ;
43614 int res1 = 0 ;
43615 bool val2 ;
43616 int ecode2 = 0 ;
43617 PyObject * obj0 = 0 ;
43618 PyObject * obj1 = 0 ;
43619 char * kwnames[] = {
43620 (char *) "self",(char *) "enable", NULL
43621 };
43622
43623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43625 if (!SWIG_IsOK(res1)) {
43626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43627 }
43628 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43629 if (obj1) {
43630 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43631 if (!SWIG_IsOK(ecode2)) {
43632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43633 }
43634 arg2 = static_cast< bool >(val2);
43635 }
43636 {
43637 PyThreadState* __tstate = wxPyBeginAllowThreads();
43638 (arg1)->Enable(arg2);
43639 wxPyEndAllowThreads(__tstate);
43640 if (PyErr_Occurred()) SWIG_fail;
43641 }
43642 resultobj = SWIG_Py_Void();
43643 return resultobj;
43644 fail:
43645 return NULL;
43646 }
43647
43648
43649 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43650 PyObject *resultobj = 0;
43651 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43652 bool result;
43653 void *argp1 = 0 ;
43654 int res1 = 0 ;
43655 PyObject *swig_obj[1] ;
43656
43657 if (!args) SWIG_fail;
43658 swig_obj[0] = args;
43659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43660 if (!SWIG_IsOK(res1)) {
43661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43662 }
43663 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43664 {
43665 PyThreadState* __tstate = wxPyBeginAllowThreads();
43666 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43667 wxPyEndAllowThreads(__tstate);
43668 if (PyErr_Occurred()) SWIG_fail;
43669 }
43670 {
43671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43672 }
43673 return resultobj;
43674 fail:
43675 return NULL;
43676 }
43677
43678
43679 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43680 PyObject *resultobj = 0;
43681 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43682 bool arg2 = (bool) true ;
43683 void *argp1 = 0 ;
43684 int res1 = 0 ;
43685 bool val2 ;
43686 int ecode2 = 0 ;
43687 PyObject * obj0 = 0 ;
43688 PyObject * obj1 = 0 ;
43689 char * kwnames[] = {
43690 (char *) "self",(char *) "check", NULL
43691 };
43692
43693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43695 if (!SWIG_IsOK(res1)) {
43696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43697 }
43698 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43699 if (obj1) {
43700 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43701 if (!SWIG_IsOK(ecode2)) {
43702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43703 }
43704 arg2 = static_cast< bool >(val2);
43705 }
43706 {
43707 PyThreadState* __tstate = wxPyBeginAllowThreads();
43708 (arg1)->Check(arg2);
43709 wxPyEndAllowThreads(__tstate);
43710 if (PyErr_Occurred()) SWIG_fail;
43711 }
43712 resultobj = SWIG_Py_Void();
43713 return resultobj;
43714 fail:
43715 return NULL;
43716 }
43717
43718
43719 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43720 PyObject *resultobj = 0;
43721 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43722 bool result;
43723 void *argp1 = 0 ;
43724 int res1 = 0 ;
43725 PyObject *swig_obj[1] ;
43726
43727 if (!args) SWIG_fail;
43728 swig_obj[0] = args;
43729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43730 if (!SWIG_IsOK(res1)) {
43731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43732 }
43733 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43734 {
43735 PyThreadState* __tstate = wxPyBeginAllowThreads();
43736 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43737 wxPyEndAllowThreads(__tstate);
43738 if (PyErr_Occurred()) SWIG_fail;
43739 }
43740 {
43741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43742 }
43743 return resultobj;
43744 fail:
43745 return NULL;
43746 }
43747
43748
43749 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43750 PyObject *resultobj = 0;
43751 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43752 void *argp1 = 0 ;
43753 int res1 = 0 ;
43754 PyObject *swig_obj[1] ;
43755
43756 if (!args) SWIG_fail;
43757 swig_obj[0] = args;
43758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43759 if (!SWIG_IsOK(res1)) {
43760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43761 }
43762 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43763 {
43764 PyThreadState* __tstate = wxPyBeginAllowThreads();
43765 (arg1)->Toggle();
43766 wxPyEndAllowThreads(__tstate);
43767 if (PyErr_Occurred()) SWIG_fail;
43768 }
43769 resultobj = SWIG_Py_Void();
43770 return resultobj;
43771 fail:
43772 return NULL;
43773 }
43774
43775
43776 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43777 PyObject *resultobj = 0;
43778 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43779 wxString *arg2 = 0 ;
43780 void *argp1 = 0 ;
43781 int res1 = 0 ;
43782 bool temp2 = false ;
43783 PyObject * obj0 = 0 ;
43784 PyObject * obj1 = 0 ;
43785 char * kwnames[] = {
43786 (char *) "self",(char *) "str", NULL
43787 };
43788
43789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43791 if (!SWIG_IsOK(res1)) {
43792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43793 }
43794 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43795 {
43796 arg2 = wxString_in_helper(obj1);
43797 if (arg2 == NULL) SWIG_fail;
43798 temp2 = true;
43799 }
43800 {
43801 PyThreadState* __tstate = wxPyBeginAllowThreads();
43802 (arg1)->SetHelp((wxString const &)*arg2);
43803 wxPyEndAllowThreads(__tstate);
43804 if (PyErr_Occurred()) SWIG_fail;
43805 }
43806 resultobj = SWIG_Py_Void();
43807 {
43808 if (temp2)
43809 delete arg2;
43810 }
43811 return resultobj;
43812 fail:
43813 {
43814 if (temp2)
43815 delete arg2;
43816 }
43817 return NULL;
43818 }
43819
43820
43821 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43822 PyObject *resultobj = 0;
43823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43824 wxString *result = 0 ;
43825 void *argp1 = 0 ;
43826 int res1 = 0 ;
43827 PyObject *swig_obj[1] ;
43828
43829 if (!args) SWIG_fail;
43830 swig_obj[0] = args;
43831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43832 if (!SWIG_IsOK(res1)) {
43833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43834 }
43835 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43836 {
43837 PyThreadState* __tstate = wxPyBeginAllowThreads();
43838 {
43839 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43840 result = (wxString *) &_result_ref;
43841 }
43842 wxPyEndAllowThreads(__tstate);
43843 if (PyErr_Occurred()) SWIG_fail;
43844 }
43845 {
43846 #if wxUSE_UNICODE
43847 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43848 #else
43849 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43850 #endif
43851 }
43852 return resultobj;
43853 fail:
43854 return NULL;
43855 }
43856
43857
43858 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43859 PyObject *resultobj = 0;
43860 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43861 wxAcceleratorEntry *result = 0 ;
43862 void *argp1 = 0 ;
43863 int res1 = 0 ;
43864 PyObject *swig_obj[1] ;
43865
43866 if (!args) SWIG_fail;
43867 swig_obj[0] = args;
43868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43869 if (!SWIG_IsOK(res1)) {
43870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43871 }
43872 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43873 {
43874 PyThreadState* __tstate = wxPyBeginAllowThreads();
43875 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43876 wxPyEndAllowThreads(__tstate);
43877 if (PyErr_Occurred()) SWIG_fail;
43878 }
43879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43880 return resultobj;
43881 fail:
43882 return NULL;
43883 }
43884
43885
43886 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43887 PyObject *resultobj = 0;
43888 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43889 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43890 void *argp1 = 0 ;
43891 int res1 = 0 ;
43892 void *argp2 = 0 ;
43893 int res2 = 0 ;
43894 PyObject * obj0 = 0 ;
43895 PyObject * obj1 = 0 ;
43896 char * kwnames[] = {
43897 (char *) "self",(char *) "accel", NULL
43898 };
43899
43900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43902 if (!SWIG_IsOK(res1)) {
43903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43904 }
43905 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43906 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43907 if (!SWIG_IsOK(res2)) {
43908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43909 }
43910 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43911 {
43912 PyThreadState* __tstate = wxPyBeginAllowThreads();
43913 (arg1)->SetAccel(arg2);
43914 wxPyEndAllowThreads(__tstate);
43915 if (PyErr_Occurred()) SWIG_fail;
43916 }
43917 resultobj = SWIG_Py_Void();
43918 return resultobj;
43919 fail:
43920 return NULL;
43921 }
43922
43923
43924 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43925 PyObject *resultobj = 0;
43926 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43927 wxBitmap *arg2 = 0 ;
43928 void *argp1 = 0 ;
43929 int res1 = 0 ;
43930 void *argp2 = 0 ;
43931 int res2 = 0 ;
43932 PyObject * obj0 = 0 ;
43933 PyObject * obj1 = 0 ;
43934 char * kwnames[] = {
43935 (char *) "self",(char *) "bitmap", NULL
43936 };
43937
43938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43940 if (!SWIG_IsOK(res1)) {
43941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43942 }
43943 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43944 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43945 if (!SWIG_IsOK(res2)) {
43946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43947 }
43948 if (!argp2) {
43949 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43950 }
43951 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43952 {
43953 PyThreadState* __tstate = wxPyBeginAllowThreads();
43954 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43955 wxPyEndAllowThreads(__tstate);
43956 if (PyErr_Occurred()) SWIG_fail;
43957 }
43958 resultobj = SWIG_Py_Void();
43959 return resultobj;
43960 fail:
43961 return NULL;
43962 }
43963
43964
43965 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43966 PyObject *resultobj = 0;
43967 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43968 wxBitmap *result = 0 ;
43969 void *argp1 = 0 ;
43970 int res1 = 0 ;
43971 PyObject *swig_obj[1] ;
43972
43973 if (!args) SWIG_fail;
43974 swig_obj[0] = args;
43975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43976 if (!SWIG_IsOK(res1)) {
43977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43978 }
43979 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43980 {
43981 PyThreadState* __tstate = wxPyBeginAllowThreads();
43982 {
43983 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43984 result = (wxBitmap *) &_result_ref;
43985 }
43986 wxPyEndAllowThreads(__tstate);
43987 if (PyErr_Occurred()) SWIG_fail;
43988 }
43989 {
43990 wxBitmap* resultptr = new wxBitmap(*result);
43991 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43992 }
43993 return resultobj;
43994 fail:
43995 return NULL;
43996 }
43997
43998
43999 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44000 PyObject *resultobj = 0;
44001 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44002 wxFont *arg2 = 0 ;
44003 void *argp1 = 0 ;
44004 int res1 = 0 ;
44005 void *argp2 = 0 ;
44006 int res2 = 0 ;
44007 PyObject * obj0 = 0 ;
44008 PyObject * obj1 = 0 ;
44009 char * kwnames[] = {
44010 (char *) "self",(char *) "font", NULL
44011 };
44012
44013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
44014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44015 if (!SWIG_IsOK(res1)) {
44016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44017 }
44018 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44019 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44020 if (!SWIG_IsOK(res2)) {
44021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44022 }
44023 if (!argp2) {
44024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44025 }
44026 arg2 = reinterpret_cast< wxFont * >(argp2);
44027 {
44028 PyThreadState* __tstate = wxPyBeginAllowThreads();
44029 (arg1)->SetFont((wxFont const &)*arg2);
44030 wxPyEndAllowThreads(__tstate);
44031 if (PyErr_Occurred()) SWIG_fail;
44032 }
44033 resultobj = SWIG_Py_Void();
44034 return resultobj;
44035 fail:
44036 return NULL;
44037 }
44038
44039
44040 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44041 PyObject *resultobj = 0;
44042 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44043 wxFont result;
44044 void *argp1 = 0 ;
44045 int res1 = 0 ;
44046 PyObject *swig_obj[1] ;
44047
44048 if (!args) SWIG_fail;
44049 swig_obj[0] = args;
44050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44051 if (!SWIG_IsOK(res1)) {
44052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44053 }
44054 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44055 {
44056 PyThreadState* __tstate = wxPyBeginAllowThreads();
44057 result = (arg1)->GetFont();
44058 wxPyEndAllowThreads(__tstate);
44059 if (PyErr_Occurred()) SWIG_fail;
44060 }
44061 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44062 return resultobj;
44063 fail:
44064 return NULL;
44065 }
44066
44067
44068 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44069 PyObject *resultobj = 0;
44070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44071 wxColour *arg2 = 0 ;
44072 void *argp1 = 0 ;
44073 int res1 = 0 ;
44074 wxColour temp2 ;
44075 PyObject * obj0 = 0 ;
44076 PyObject * obj1 = 0 ;
44077 char * kwnames[] = {
44078 (char *) "self",(char *) "colText", NULL
44079 };
44080
44081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44083 if (!SWIG_IsOK(res1)) {
44084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44085 }
44086 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44087 {
44088 arg2 = &temp2;
44089 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44090 }
44091 {
44092 PyThreadState* __tstate = wxPyBeginAllowThreads();
44093 (arg1)->SetTextColour((wxColour const &)*arg2);
44094 wxPyEndAllowThreads(__tstate);
44095 if (PyErr_Occurred()) SWIG_fail;
44096 }
44097 resultobj = SWIG_Py_Void();
44098 return resultobj;
44099 fail:
44100 return NULL;
44101 }
44102
44103
44104 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44105 PyObject *resultobj = 0;
44106 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44107 wxColour result;
44108 void *argp1 = 0 ;
44109 int res1 = 0 ;
44110 PyObject *swig_obj[1] ;
44111
44112 if (!args) SWIG_fail;
44113 swig_obj[0] = args;
44114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44115 if (!SWIG_IsOK(res1)) {
44116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44117 }
44118 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44119 {
44120 PyThreadState* __tstate = wxPyBeginAllowThreads();
44121 result = (arg1)->GetTextColour();
44122 wxPyEndAllowThreads(__tstate);
44123 if (PyErr_Occurred()) SWIG_fail;
44124 }
44125 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44126 return resultobj;
44127 fail:
44128 return NULL;
44129 }
44130
44131
44132 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44133 PyObject *resultobj = 0;
44134 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44135 wxColour *arg2 = 0 ;
44136 void *argp1 = 0 ;
44137 int res1 = 0 ;
44138 wxColour temp2 ;
44139 PyObject * obj0 = 0 ;
44140 PyObject * obj1 = 0 ;
44141 char * kwnames[] = {
44142 (char *) "self",(char *) "colBack", NULL
44143 };
44144
44145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44147 if (!SWIG_IsOK(res1)) {
44148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44149 }
44150 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44151 {
44152 arg2 = &temp2;
44153 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44154 }
44155 {
44156 PyThreadState* __tstate = wxPyBeginAllowThreads();
44157 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
44158 wxPyEndAllowThreads(__tstate);
44159 if (PyErr_Occurred()) SWIG_fail;
44160 }
44161 resultobj = SWIG_Py_Void();
44162 return resultobj;
44163 fail:
44164 return NULL;
44165 }
44166
44167
44168 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44169 PyObject *resultobj = 0;
44170 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44171 wxColour result;
44172 void *argp1 = 0 ;
44173 int res1 = 0 ;
44174 PyObject *swig_obj[1] ;
44175
44176 if (!args) SWIG_fail;
44177 swig_obj[0] = args;
44178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44179 if (!SWIG_IsOK(res1)) {
44180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44181 }
44182 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44183 {
44184 PyThreadState* __tstate = wxPyBeginAllowThreads();
44185 result = (arg1)->GetBackgroundColour();
44186 wxPyEndAllowThreads(__tstate);
44187 if (PyErr_Occurred()) SWIG_fail;
44188 }
44189 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44190 return resultobj;
44191 fail:
44192 return NULL;
44193 }
44194
44195
44196 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44197 PyObject *resultobj = 0;
44198 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44199 wxBitmap *arg2 = 0 ;
44200 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44201 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44202 void *argp1 = 0 ;
44203 int res1 = 0 ;
44204 void *argp2 = 0 ;
44205 int res2 = 0 ;
44206 void *argp3 = 0 ;
44207 int res3 = 0 ;
44208 PyObject * obj0 = 0 ;
44209 PyObject * obj1 = 0 ;
44210 PyObject * obj2 = 0 ;
44211 char * kwnames[] = {
44212 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44213 };
44214
44215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44217 if (!SWIG_IsOK(res1)) {
44218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44219 }
44220 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44221 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44222 if (!SWIG_IsOK(res2)) {
44223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44224 }
44225 if (!argp2) {
44226 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44227 }
44228 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44229 if (obj2) {
44230 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44231 if (!SWIG_IsOK(res3)) {
44232 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44233 }
44234 if (!argp3) {
44235 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44236 }
44237 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44238 }
44239 {
44240 PyThreadState* __tstate = wxPyBeginAllowThreads();
44241 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44242 wxPyEndAllowThreads(__tstate);
44243 if (PyErr_Occurred()) SWIG_fail;
44244 }
44245 resultobj = SWIG_Py_Void();
44246 return resultobj;
44247 fail:
44248 return NULL;
44249 }
44250
44251
44252 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44253 PyObject *resultobj = 0;
44254 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44255 wxBitmap *arg2 = 0 ;
44256 void *argp1 = 0 ;
44257 int res1 = 0 ;
44258 void *argp2 = 0 ;
44259 int res2 = 0 ;
44260 PyObject * obj0 = 0 ;
44261 PyObject * obj1 = 0 ;
44262 char * kwnames[] = {
44263 (char *) "self",(char *) "bmpDisabled", NULL
44264 };
44265
44266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44268 if (!SWIG_IsOK(res1)) {
44269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44270 }
44271 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44272 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44273 if (!SWIG_IsOK(res2)) {
44274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44275 }
44276 if (!argp2) {
44277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44278 }
44279 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44280 {
44281 PyThreadState* __tstate = wxPyBeginAllowThreads();
44282 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
44283 wxPyEndAllowThreads(__tstate);
44284 if (PyErr_Occurred()) SWIG_fail;
44285 }
44286 resultobj = SWIG_Py_Void();
44287 return resultobj;
44288 fail:
44289 return NULL;
44290 }
44291
44292
44293 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44294 PyObject *resultobj = 0;
44295 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44296 wxBitmap *result = 0 ;
44297 void *argp1 = 0 ;
44298 int res1 = 0 ;
44299 PyObject *swig_obj[1] ;
44300
44301 if (!args) SWIG_fail;
44302 swig_obj[0] = args;
44303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44304 if (!SWIG_IsOK(res1)) {
44305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44306 }
44307 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44308 {
44309 PyThreadState* __tstate = wxPyBeginAllowThreads();
44310 {
44311 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
44312 result = (wxBitmap *) &_result_ref;
44313 }
44314 wxPyEndAllowThreads(__tstate);
44315 if (PyErr_Occurred()) SWIG_fail;
44316 }
44317 {
44318 wxBitmap* resultptr = new wxBitmap(*result);
44319 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44320 }
44321 return resultobj;
44322 fail:
44323 return NULL;
44324 }
44325
44326
44327 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44328 PyObject *resultobj = 0;
44329 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44330 int arg2 ;
44331 void *argp1 = 0 ;
44332 int res1 = 0 ;
44333 int val2 ;
44334 int ecode2 = 0 ;
44335 PyObject * obj0 = 0 ;
44336 PyObject * obj1 = 0 ;
44337 char * kwnames[] = {
44338 (char *) "self",(char *) "nWidth", NULL
44339 };
44340
44341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44343 if (!SWIG_IsOK(res1)) {
44344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44345 }
44346 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44347 ecode2 = SWIG_AsVal_int(obj1, &val2);
44348 if (!SWIG_IsOK(ecode2)) {
44349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44350 }
44351 arg2 = static_cast< int >(val2);
44352 {
44353 PyThreadState* __tstate = wxPyBeginAllowThreads();
44354 (arg1)->SetMarginWidth(arg2);
44355 wxPyEndAllowThreads(__tstate);
44356 if (PyErr_Occurred()) SWIG_fail;
44357 }
44358 resultobj = SWIG_Py_Void();
44359 return resultobj;
44360 fail:
44361 return NULL;
44362 }
44363
44364
44365 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44366 PyObject *resultobj = 0;
44367 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44368 int result;
44369 void *argp1 = 0 ;
44370 int res1 = 0 ;
44371 PyObject *swig_obj[1] ;
44372
44373 if (!args) SWIG_fail;
44374 swig_obj[0] = args;
44375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44376 if (!SWIG_IsOK(res1)) {
44377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44378 }
44379 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44380 {
44381 PyThreadState* __tstate = wxPyBeginAllowThreads();
44382 result = (int)(arg1)->GetMarginWidth();
44383 wxPyEndAllowThreads(__tstate);
44384 if (PyErr_Occurred()) SWIG_fail;
44385 }
44386 resultobj = SWIG_From_int(static_cast< int >(result));
44387 return resultobj;
44388 fail:
44389 return NULL;
44390 }
44391
44392
44393 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44394 PyObject *resultobj = 0;
44395 int result;
44396
44397 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44398 {
44399 PyThreadState* __tstate = wxPyBeginAllowThreads();
44400 result = (int)wxMenuItem::GetDefaultMarginWidth();
44401 wxPyEndAllowThreads(__tstate);
44402 if (PyErr_Occurred()) SWIG_fail;
44403 }
44404 resultobj = SWIG_From_int(static_cast< int >(result));
44405 return resultobj;
44406 fail:
44407 return NULL;
44408 }
44409
44410
44411 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44412 PyObject *resultobj = 0;
44413 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44414 bool result;
44415 void *argp1 = 0 ;
44416 int res1 = 0 ;
44417 PyObject *swig_obj[1] ;
44418
44419 if (!args) SWIG_fail;
44420 swig_obj[0] = args;
44421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44422 if (!SWIG_IsOK(res1)) {
44423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44424 }
44425 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44426 {
44427 PyThreadState* __tstate = wxPyBeginAllowThreads();
44428 result = (bool)(arg1)->IsOwnerDrawn();
44429 wxPyEndAllowThreads(__tstate);
44430 if (PyErr_Occurred()) SWIG_fail;
44431 }
44432 {
44433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44434 }
44435 return resultobj;
44436 fail:
44437 return NULL;
44438 }
44439
44440
44441 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44442 PyObject *resultobj = 0;
44443 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44444 bool arg2 = (bool) true ;
44445 void *argp1 = 0 ;
44446 int res1 = 0 ;
44447 bool val2 ;
44448 int ecode2 = 0 ;
44449 PyObject * obj0 = 0 ;
44450 PyObject * obj1 = 0 ;
44451 char * kwnames[] = {
44452 (char *) "self",(char *) "ownerDrawn", NULL
44453 };
44454
44455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44457 if (!SWIG_IsOK(res1)) {
44458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44459 }
44460 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44461 if (obj1) {
44462 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44463 if (!SWIG_IsOK(ecode2)) {
44464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44465 }
44466 arg2 = static_cast< bool >(val2);
44467 }
44468 {
44469 PyThreadState* __tstate = wxPyBeginAllowThreads();
44470 (arg1)->SetOwnerDrawn(arg2);
44471 wxPyEndAllowThreads(__tstate);
44472 if (PyErr_Occurred()) SWIG_fail;
44473 }
44474 resultobj = SWIG_Py_Void();
44475 return resultobj;
44476 fail:
44477 return NULL;
44478 }
44479
44480
44481 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44482 PyObject *resultobj = 0;
44483 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44484 void *argp1 = 0 ;
44485 int res1 = 0 ;
44486 PyObject *swig_obj[1] ;
44487
44488 if (!args) SWIG_fail;
44489 swig_obj[0] = args;
44490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44491 if (!SWIG_IsOK(res1)) {
44492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44493 }
44494 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44495 {
44496 PyThreadState* __tstate = wxPyBeginAllowThreads();
44497 (arg1)->ResetOwnerDrawn();
44498 wxPyEndAllowThreads(__tstate);
44499 if (PyErr_Occurred()) SWIG_fail;
44500 }
44501 resultobj = SWIG_Py_Void();
44502 return resultobj;
44503 fail:
44504 return NULL;
44505 }
44506
44507
44508 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44509 PyObject *obj;
44510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44511 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44512 return SWIG_Py_Void();
44513 }
44514
44515 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44516 return SWIG_Python_InitShadowInstance(args);
44517 }
44518
44519 SWIGINTERN int ControlNameStr_set(PyObject *) {
44520 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44521 return 1;
44522 }
44523
44524
44525 SWIGINTERN PyObject *ControlNameStr_get(void) {
44526 PyObject *pyobj = 0;
44527
44528 {
44529 #if wxUSE_UNICODE
44530 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44531 #else
44532 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44533 #endif
44534 }
44535 return pyobj;
44536 }
44537
44538
44539 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44540 PyObject *resultobj = 0;
44541 wxWindow *arg1 = (wxWindow *) 0 ;
44542 int arg2 = (int) -1 ;
44543 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44544 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44545 wxSize const &arg4_defvalue = wxDefaultSize ;
44546 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44547 long arg5 = (long) 0 ;
44548 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44549 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44550 wxString const &arg7_defvalue = wxPyControlNameStr ;
44551 wxString *arg7 = (wxString *) &arg7_defvalue ;
44552 wxControl *result = 0 ;
44553 void *argp1 = 0 ;
44554 int res1 = 0 ;
44555 int val2 ;
44556 int ecode2 = 0 ;
44557 wxPoint temp3 ;
44558 wxSize temp4 ;
44559 long val5 ;
44560 int ecode5 = 0 ;
44561 void *argp6 = 0 ;
44562 int res6 = 0 ;
44563 bool temp7 = false ;
44564 PyObject * obj0 = 0 ;
44565 PyObject * obj1 = 0 ;
44566 PyObject * obj2 = 0 ;
44567 PyObject * obj3 = 0 ;
44568 PyObject * obj4 = 0 ;
44569 PyObject * obj5 = 0 ;
44570 PyObject * obj6 = 0 ;
44571 char * kwnames[] = {
44572 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44573 };
44574
44575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44577 if (!SWIG_IsOK(res1)) {
44578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44579 }
44580 arg1 = reinterpret_cast< wxWindow * >(argp1);
44581 if (obj1) {
44582 ecode2 = SWIG_AsVal_int(obj1, &val2);
44583 if (!SWIG_IsOK(ecode2)) {
44584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44585 }
44586 arg2 = static_cast< int >(val2);
44587 }
44588 if (obj2) {
44589 {
44590 arg3 = &temp3;
44591 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44592 }
44593 }
44594 if (obj3) {
44595 {
44596 arg4 = &temp4;
44597 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44598 }
44599 }
44600 if (obj4) {
44601 ecode5 = SWIG_AsVal_long(obj4, &val5);
44602 if (!SWIG_IsOK(ecode5)) {
44603 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44604 }
44605 arg5 = static_cast< long >(val5);
44606 }
44607 if (obj5) {
44608 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44609 if (!SWIG_IsOK(res6)) {
44610 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44611 }
44612 if (!argp6) {
44613 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44614 }
44615 arg6 = reinterpret_cast< wxValidator * >(argp6);
44616 }
44617 if (obj6) {
44618 {
44619 arg7 = wxString_in_helper(obj6);
44620 if (arg7 == NULL) SWIG_fail;
44621 temp7 = true;
44622 }
44623 }
44624 {
44625 if (!wxPyCheckForApp()) SWIG_fail;
44626 PyThreadState* __tstate = wxPyBeginAllowThreads();
44627 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44628 wxPyEndAllowThreads(__tstate);
44629 if (PyErr_Occurred()) SWIG_fail;
44630 }
44631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44632 {
44633 if (temp7)
44634 delete arg7;
44635 }
44636 return resultobj;
44637 fail:
44638 {
44639 if (temp7)
44640 delete arg7;
44641 }
44642 return NULL;
44643 }
44644
44645
44646 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44647 PyObject *resultobj = 0;
44648 wxControl *result = 0 ;
44649
44650 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44651 {
44652 if (!wxPyCheckForApp()) SWIG_fail;
44653 PyThreadState* __tstate = wxPyBeginAllowThreads();
44654 result = (wxControl *)new wxControl();
44655 wxPyEndAllowThreads(__tstate);
44656 if (PyErr_Occurred()) SWIG_fail;
44657 }
44658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44659 return resultobj;
44660 fail:
44661 return NULL;
44662 }
44663
44664
44665 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44666 PyObject *resultobj = 0;
44667 wxControl *arg1 = (wxControl *) 0 ;
44668 wxWindow *arg2 = (wxWindow *) 0 ;
44669 int arg3 = (int) -1 ;
44670 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44671 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44672 wxSize const &arg5_defvalue = wxDefaultSize ;
44673 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44674 long arg6 = (long) 0 ;
44675 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44676 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44677 wxString const &arg8_defvalue = wxPyControlNameStr ;
44678 wxString *arg8 = (wxString *) &arg8_defvalue ;
44679 bool result;
44680 void *argp1 = 0 ;
44681 int res1 = 0 ;
44682 void *argp2 = 0 ;
44683 int res2 = 0 ;
44684 int val3 ;
44685 int ecode3 = 0 ;
44686 wxPoint temp4 ;
44687 wxSize temp5 ;
44688 long val6 ;
44689 int ecode6 = 0 ;
44690 void *argp7 = 0 ;
44691 int res7 = 0 ;
44692 bool temp8 = false ;
44693 PyObject * obj0 = 0 ;
44694 PyObject * obj1 = 0 ;
44695 PyObject * obj2 = 0 ;
44696 PyObject * obj3 = 0 ;
44697 PyObject * obj4 = 0 ;
44698 PyObject * obj5 = 0 ;
44699 PyObject * obj6 = 0 ;
44700 PyObject * obj7 = 0 ;
44701 char * kwnames[] = {
44702 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44703 };
44704
44705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44707 if (!SWIG_IsOK(res1)) {
44708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44709 }
44710 arg1 = reinterpret_cast< wxControl * >(argp1);
44711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44712 if (!SWIG_IsOK(res2)) {
44713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44714 }
44715 arg2 = reinterpret_cast< wxWindow * >(argp2);
44716 if (obj2) {
44717 ecode3 = SWIG_AsVal_int(obj2, &val3);
44718 if (!SWIG_IsOK(ecode3)) {
44719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44720 }
44721 arg3 = static_cast< int >(val3);
44722 }
44723 if (obj3) {
44724 {
44725 arg4 = &temp4;
44726 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44727 }
44728 }
44729 if (obj4) {
44730 {
44731 arg5 = &temp5;
44732 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44733 }
44734 }
44735 if (obj5) {
44736 ecode6 = SWIG_AsVal_long(obj5, &val6);
44737 if (!SWIG_IsOK(ecode6)) {
44738 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44739 }
44740 arg6 = static_cast< long >(val6);
44741 }
44742 if (obj6) {
44743 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44744 if (!SWIG_IsOK(res7)) {
44745 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44746 }
44747 if (!argp7) {
44748 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44749 }
44750 arg7 = reinterpret_cast< wxValidator * >(argp7);
44751 }
44752 if (obj7) {
44753 {
44754 arg8 = wxString_in_helper(obj7);
44755 if (arg8 == NULL) SWIG_fail;
44756 temp8 = true;
44757 }
44758 }
44759 {
44760 PyThreadState* __tstate = wxPyBeginAllowThreads();
44761 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44762 wxPyEndAllowThreads(__tstate);
44763 if (PyErr_Occurred()) SWIG_fail;
44764 }
44765 {
44766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44767 }
44768 {
44769 if (temp8)
44770 delete arg8;
44771 }
44772 return resultobj;
44773 fail:
44774 {
44775 if (temp8)
44776 delete arg8;
44777 }
44778 return NULL;
44779 }
44780
44781
44782 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44783 PyObject *resultobj = 0;
44784 wxControl *arg1 = (wxControl *) 0 ;
44785 int result;
44786 void *argp1 = 0 ;
44787 int res1 = 0 ;
44788 PyObject *swig_obj[1] ;
44789
44790 if (!args) SWIG_fail;
44791 swig_obj[0] = args;
44792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44793 if (!SWIG_IsOK(res1)) {
44794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44795 }
44796 arg1 = reinterpret_cast< wxControl * >(argp1);
44797 {
44798 PyThreadState* __tstate = wxPyBeginAllowThreads();
44799 result = (int)((wxControl const *)arg1)->GetAlignment();
44800 wxPyEndAllowThreads(__tstate);
44801 if (PyErr_Occurred()) SWIG_fail;
44802 }
44803 resultobj = SWIG_From_int(static_cast< int >(result));
44804 return resultobj;
44805 fail:
44806 return NULL;
44807 }
44808
44809
44810 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44811 PyObject *resultobj = 0;
44812 wxControl *arg1 = (wxControl *) 0 ;
44813 wxString result;
44814 void *argp1 = 0 ;
44815 int res1 = 0 ;
44816 PyObject *swig_obj[1] ;
44817
44818 if (!args) SWIG_fail;
44819 swig_obj[0] = args;
44820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44821 if (!SWIG_IsOK(res1)) {
44822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44823 }
44824 arg1 = reinterpret_cast< wxControl * >(argp1);
44825 {
44826 PyThreadState* __tstate = wxPyBeginAllowThreads();
44827 result = ((wxControl const *)arg1)->GetLabelText();
44828 wxPyEndAllowThreads(__tstate);
44829 if (PyErr_Occurred()) SWIG_fail;
44830 }
44831 {
44832 #if wxUSE_UNICODE
44833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44834 #else
44835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44836 #endif
44837 }
44838 return resultobj;
44839 fail:
44840 return NULL;
44841 }
44842
44843
44844 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44845 PyObject *resultobj = 0;
44846 wxControl *arg1 = (wxControl *) 0 ;
44847 wxCommandEvent *arg2 = 0 ;
44848 void *argp1 = 0 ;
44849 int res1 = 0 ;
44850 void *argp2 = 0 ;
44851 int res2 = 0 ;
44852 PyObject * obj0 = 0 ;
44853 PyObject * obj1 = 0 ;
44854 char * kwnames[] = {
44855 (char *) "self",(char *) "event", NULL
44856 };
44857
44858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44860 if (!SWIG_IsOK(res1)) {
44861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44862 }
44863 arg1 = reinterpret_cast< wxControl * >(argp1);
44864 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44865 if (!SWIG_IsOK(res2)) {
44866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44867 }
44868 if (!argp2) {
44869 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44870 }
44871 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44872 {
44873 PyThreadState* __tstate = wxPyBeginAllowThreads();
44874 (arg1)->Command(*arg2);
44875 wxPyEndAllowThreads(__tstate);
44876 if (PyErr_Occurred()) SWIG_fail;
44877 }
44878 resultobj = SWIG_Py_Void();
44879 return resultobj;
44880 fail:
44881 return NULL;
44882 }
44883
44884
44885 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44886 PyObject *resultobj = 0;
44887 wxControl *arg1 = (wxControl *) 0 ;
44888 wxString result;
44889 void *argp1 = 0 ;
44890 int res1 = 0 ;
44891 PyObject *swig_obj[1] ;
44892
44893 if (!args) SWIG_fail;
44894 swig_obj[0] = args;
44895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44896 if (!SWIG_IsOK(res1)) {
44897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44898 }
44899 arg1 = reinterpret_cast< wxControl * >(argp1);
44900 {
44901 PyThreadState* __tstate = wxPyBeginAllowThreads();
44902 result = (arg1)->GetLabel();
44903 wxPyEndAllowThreads(__tstate);
44904 if (PyErr_Occurred()) SWIG_fail;
44905 }
44906 {
44907 #if wxUSE_UNICODE
44908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44909 #else
44910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44911 #endif
44912 }
44913 return resultobj;
44914 fail:
44915 return NULL;
44916 }
44917
44918
44919 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44920 PyObject *resultobj = 0;
44921 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44922 SwigValueWrapper<wxVisualAttributes > result;
44923 int val1 ;
44924 int ecode1 = 0 ;
44925 PyObject * obj0 = 0 ;
44926 char * kwnames[] = {
44927 (char *) "variant", NULL
44928 };
44929
44930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44931 if (obj0) {
44932 ecode1 = SWIG_AsVal_int(obj0, &val1);
44933 if (!SWIG_IsOK(ecode1)) {
44934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44935 }
44936 arg1 = static_cast< wxWindowVariant >(val1);
44937 }
44938 {
44939 if (!wxPyCheckForApp()) SWIG_fail;
44940 PyThreadState* __tstate = wxPyBeginAllowThreads();
44941 result = wxControl::GetClassDefaultAttributes(arg1);
44942 wxPyEndAllowThreads(__tstate);
44943 if (PyErr_Occurred()) SWIG_fail;
44944 }
44945 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44946 return resultobj;
44947 fail:
44948 return NULL;
44949 }
44950
44951
44952 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44953 PyObject *obj;
44954 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44955 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44956 return SWIG_Py_Void();
44957 }
44958
44959 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44960 return SWIG_Python_InitShadowInstance(args);
44961 }
44962
44963 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44964 PyObject *resultobj = 0;
44965 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44966 wxString *arg2 = 0 ;
44967 PyObject *arg3 = (PyObject *) NULL ;
44968 int result;
44969 void *argp1 = 0 ;
44970 int res1 = 0 ;
44971 bool temp2 = false ;
44972 PyObject * obj0 = 0 ;
44973 PyObject * obj1 = 0 ;
44974 PyObject * obj2 = 0 ;
44975 char * kwnames[] = {
44976 (char *) "self",(char *) "item",(char *) "clientData", NULL
44977 };
44978
44979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44981 if (!SWIG_IsOK(res1)) {
44982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44983 }
44984 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44985 {
44986 arg2 = wxString_in_helper(obj1);
44987 if (arg2 == NULL) SWIG_fail;
44988 temp2 = true;
44989 }
44990 if (obj2) {
44991 arg3 = obj2;
44992 }
44993 {
44994 PyThreadState* __tstate = wxPyBeginAllowThreads();
44995 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44996 wxPyEndAllowThreads(__tstate);
44997 if (PyErr_Occurred()) SWIG_fail;
44998 }
44999 resultobj = SWIG_From_int(static_cast< int >(result));
45000 {
45001 if (temp2)
45002 delete arg2;
45003 }
45004 return resultobj;
45005 fail:
45006 {
45007 if (temp2)
45008 delete arg2;
45009 }
45010 return NULL;
45011 }
45012
45013
45014 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45015 PyObject *resultobj = 0;
45016 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45017 wxArrayString *arg2 = 0 ;
45018 void *argp1 = 0 ;
45019 int res1 = 0 ;
45020 bool temp2 = false ;
45021 PyObject * obj0 = 0 ;
45022 PyObject * obj1 = 0 ;
45023 char * kwnames[] = {
45024 (char *) "self",(char *) "strings", NULL
45025 };
45026
45027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45029 if (!SWIG_IsOK(res1)) {
45030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45031 }
45032 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45033 {
45034 if (! PySequence_Check(obj1)) {
45035 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45036 SWIG_fail;
45037 }
45038 arg2 = new wxArrayString;
45039 temp2 = true;
45040 int i, len=PySequence_Length(obj1);
45041 for (i=0; i<len; i++) {
45042 PyObject* item = PySequence_GetItem(obj1, i);
45043 wxString* s = wxString_in_helper(item);
45044 if (PyErr_Occurred()) SWIG_fail;
45045 arg2->Add(*s);
45046 delete s;
45047 Py_DECREF(item);
45048 }
45049 }
45050 {
45051 PyThreadState* __tstate = wxPyBeginAllowThreads();
45052 (arg1)->Append((wxArrayString const &)*arg2);
45053 wxPyEndAllowThreads(__tstate);
45054 if (PyErr_Occurred()) SWIG_fail;
45055 }
45056 resultobj = SWIG_Py_Void();
45057 {
45058 if (temp2) delete arg2;
45059 }
45060 return resultobj;
45061 fail:
45062 {
45063 if (temp2) delete arg2;
45064 }
45065 return NULL;
45066 }
45067
45068
45069 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45070 PyObject *resultobj = 0;
45071 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45072 wxString *arg2 = 0 ;
45073 unsigned int arg3 ;
45074 PyObject *arg4 = (PyObject *) NULL ;
45075 int result;
45076 void *argp1 = 0 ;
45077 int res1 = 0 ;
45078 bool temp2 = false ;
45079 unsigned int val3 ;
45080 int ecode3 = 0 ;
45081 PyObject * obj0 = 0 ;
45082 PyObject * obj1 = 0 ;
45083 PyObject * obj2 = 0 ;
45084 PyObject * obj3 = 0 ;
45085 char * kwnames[] = {
45086 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45087 };
45088
45089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45091 if (!SWIG_IsOK(res1)) {
45092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45093 }
45094 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45095 {
45096 arg2 = wxString_in_helper(obj1);
45097 if (arg2 == NULL) SWIG_fail;
45098 temp2 = true;
45099 }
45100 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45101 if (!SWIG_IsOK(ecode3)) {
45102 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45103 }
45104 arg3 = static_cast< unsigned int >(val3);
45105 if (obj3) {
45106 arg4 = obj3;
45107 }
45108 {
45109 PyThreadState* __tstate = wxPyBeginAllowThreads();
45110 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45111 wxPyEndAllowThreads(__tstate);
45112 if (PyErr_Occurred()) SWIG_fail;
45113 }
45114 resultobj = SWIG_From_int(static_cast< int >(result));
45115 {
45116 if (temp2)
45117 delete arg2;
45118 }
45119 return resultobj;
45120 fail:
45121 {
45122 if (temp2)
45123 delete arg2;
45124 }
45125 return NULL;
45126 }
45127
45128
45129 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45130 PyObject *resultobj = 0;
45131 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45132 void *argp1 = 0 ;
45133 int res1 = 0 ;
45134 PyObject *swig_obj[1] ;
45135
45136 if (!args) SWIG_fail;
45137 swig_obj[0] = args;
45138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45139 if (!SWIG_IsOK(res1)) {
45140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45141 }
45142 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45143 {
45144 PyThreadState* __tstate = wxPyBeginAllowThreads();
45145 (arg1)->Clear();
45146 wxPyEndAllowThreads(__tstate);
45147 if (PyErr_Occurred()) SWIG_fail;
45148 }
45149 resultobj = SWIG_Py_Void();
45150 return resultobj;
45151 fail:
45152 return NULL;
45153 }
45154
45155
45156 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45157 PyObject *resultobj = 0;
45158 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45159 unsigned int arg2 ;
45160 void *argp1 = 0 ;
45161 int res1 = 0 ;
45162 unsigned int val2 ;
45163 int ecode2 = 0 ;
45164 PyObject * obj0 = 0 ;
45165 PyObject * obj1 = 0 ;
45166 char * kwnames[] = {
45167 (char *) "self",(char *) "n", NULL
45168 };
45169
45170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45172 if (!SWIG_IsOK(res1)) {
45173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45174 }
45175 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45176 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45177 if (!SWIG_IsOK(ecode2)) {
45178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45179 }
45180 arg2 = static_cast< unsigned int >(val2);
45181 {
45182 PyThreadState* __tstate = wxPyBeginAllowThreads();
45183 (arg1)->Delete(arg2);
45184 wxPyEndAllowThreads(__tstate);
45185 if (PyErr_Occurred()) SWIG_fail;
45186 }
45187 resultobj = SWIG_Py_Void();
45188 return resultobj;
45189 fail:
45190 return NULL;
45191 }
45192
45193
45194 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45195 PyObject *resultobj = 0;
45196 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45197 unsigned int arg2 ;
45198 PyObject *result = 0 ;
45199 void *argp1 = 0 ;
45200 int res1 = 0 ;
45201 unsigned int val2 ;
45202 int ecode2 = 0 ;
45203 PyObject * obj0 = 0 ;
45204 PyObject * obj1 = 0 ;
45205 char * kwnames[] = {
45206 (char *) "self",(char *) "n", NULL
45207 };
45208
45209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45211 if (!SWIG_IsOK(res1)) {
45212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45213 }
45214 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45215 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45216 if (!SWIG_IsOK(ecode2)) {
45217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45218 }
45219 arg2 = static_cast< unsigned int >(val2);
45220 {
45221 PyThreadState* __tstate = wxPyBeginAllowThreads();
45222 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45223 wxPyEndAllowThreads(__tstate);
45224 if (PyErr_Occurred()) SWIG_fail;
45225 }
45226 resultobj = result;
45227 return resultobj;
45228 fail:
45229 return NULL;
45230 }
45231
45232
45233 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45234 PyObject *resultobj = 0;
45235 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45236 unsigned int arg2 ;
45237 PyObject *arg3 = (PyObject *) 0 ;
45238 void *argp1 = 0 ;
45239 int res1 = 0 ;
45240 unsigned int val2 ;
45241 int ecode2 = 0 ;
45242 PyObject * obj0 = 0 ;
45243 PyObject * obj1 = 0 ;
45244 PyObject * obj2 = 0 ;
45245 char * kwnames[] = {
45246 (char *) "self",(char *) "n",(char *) "clientData", NULL
45247 };
45248
45249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45251 if (!SWIG_IsOK(res1)) {
45252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45253 }
45254 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45255 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45256 if (!SWIG_IsOK(ecode2)) {
45257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45258 }
45259 arg2 = static_cast< unsigned int >(val2);
45260 arg3 = obj2;
45261 {
45262 PyThreadState* __tstate = wxPyBeginAllowThreads();
45263 wxItemContainer_SetClientData(arg1,arg2,arg3);
45264 wxPyEndAllowThreads(__tstate);
45265 if (PyErr_Occurred()) SWIG_fail;
45266 }
45267 resultobj = SWIG_Py_Void();
45268 return resultobj;
45269 fail:
45270 return NULL;
45271 }
45272
45273
45274 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45275 PyObject *resultobj = 0;
45276 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45277 unsigned int result;
45278 void *argp1 = 0 ;
45279 int res1 = 0 ;
45280 PyObject *swig_obj[1] ;
45281
45282 if (!args) SWIG_fail;
45283 swig_obj[0] = args;
45284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45285 if (!SWIG_IsOK(res1)) {
45286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45287 }
45288 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45289 {
45290 PyThreadState* __tstate = wxPyBeginAllowThreads();
45291 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45292 wxPyEndAllowThreads(__tstate);
45293 if (PyErr_Occurred()) SWIG_fail;
45294 }
45295 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45296 return resultobj;
45297 fail:
45298 return NULL;
45299 }
45300
45301
45302 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45303 PyObject *resultobj = 0;
45304 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45305 bool result;
45306 void *argp1 = 0 ;
45307 int res1 = 0 ;
45308 PyObject *swig_obj[1] ;
45309
45310 if (!args) SWIG_fail;
45311 swig_obj[0] = args;
45312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45313 if (!SWIG_IsOK(res1)) {
45314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45315 }
45316 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45317 {
45318 PyThreadState* __tstate = wxPyBeginAllowThreads();
45319 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45320 wxPyEndAllowThreads(__tstate);
45321 if (PyErr_Occurred()) SWIG_fail;
45322 }
45323 {
45324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45325 }
45326 return resultobj;
45327 fail:
45328 return NULL;
45329 }
45330
45331
45332 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45333 PyObject *resultobj = 0;
45334 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45335 unsigned int arg2 ;
45336 wxString result;
45337 void *argp1 = 0 ;
45338 int res1 = 0 ;
45339 unsigned int val2 ;
45340 int ecode2 = 0 ;
45341 PyObject * obj0 = 0 ;
45342 PyObject * obj1 = 0 ;
45343 char * kwnames[] = {
45344 (char *) "self",(char *) "n", NULL
45345 };
45346
45347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45349 if (!SWIG_IsOK(res1)) {
45350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45351 }
45352 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45353 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45354 if (!SWIG_IsOK(ecode2)) {
45355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45356 }
45357 arg2 = static_cast< unsigned int >(val2);
45358 {
45359 PyThreadState* __tstate = wxPyBeginAllowThreads();
45360 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45361 wxPyEndAllowThreads(__tstate);
45362 if (PyErr_Occurred()) SWIG_fail;
45363 }
45364 {
45365 #if wxUSE_UNICODE
45366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45367 #else
45368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45369 #endif
45370 }
45371 return resultobj;
45372 fail:
45373 return NULL;
45374 }
45375
45376
45377 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45378 PyObject *resultobj = 0;
45379 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45380 wxArrayString result;
45381 void *argp1 = 0 ;
45382 int res1 = 0 ;
45383 PyObject *swig_obj[1] ;
45384
45385 if (!args) SWIG_fail;
45386 swig_obj[0] = args;
45387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45388 if (!SWIG_IsOK(res1)) {
45389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45390 }
45391 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45392 {
45393 PyThreadState* __tstate = wxPyBeginAllowThreads();
45394 result = ((wxItemContainer const *)arg1)->GetStrings();
45395 wxPyEndAllowThreads(__tstate);
45396 if (PyErr_Occurred()) SWIG_fail;
45397 }
45398 {
45399 resultobj = wxArrayString2PyList_helper(result);
45400 }
45401 return resultobj;
45402 fail:
45403 return NULL;
45404 }
45405
45406
45407 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45408 PyObject *resultobj = 0;
45409 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45410 unsigned int arg2 ;
45411 wxString *arg3 = 0 ;
45412 void *argp1 = 0 ;
45413 int res1 = 0 ;
45414 unsigned int val2 ;
45415 int ecode2 = 0 ;
45416 bool temp3 = false ;
45417 PyObject * obj0 = 0 ;
45418 PyObject * obj1 = 0 ;
45419 PyObject * obj2 = 0 ;
45420 char * kwnames[] = {
45421 (char *) "self",(char *) "n",(char *) "s", NULL
45422 };
45423
45424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45426 if (!SWIG_IsOK(res1)) {
45427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45428 }
45429 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45430 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45431 if (!SWIG_IsOK(ecode2)) {
45432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45433 }
45434 arg2 = static_cast< unsigned int >(val2);
45435 {
45436 arg3 = wxString_in_helper(obj2);
45437 if (arg3 == NULL) SWIG_fail;
45438 temp3 = true;
45439 }
45440 {
45441 PyThreadState* __tstate = wxPyBeginAllowThreads();
45442 (arg1)->SetString(arg2,(wxString const &)*arg3);
45443 wxPyEndAllowThreads(__tstate);
45444 if (PyErr_Occurred()) SWIG_fail;
45445 }
45446 resultobj = SWIG_Py_Void();
45447 {
45448 if (temp3)
45449 delete arg3;
45450 }
45451 return resultobj;
45452 fail:
45453 {
45454 if (temp3)
45455 delete arg3;
45456 }
45457 return NULL;
45458 }
45459
45460
45461 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45462 PyObject *resultobj = 0;
45463 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45464 wxString *arg2 = 0 ;
45465 int result;
45466 void *argp1 = 0 ;
45467 int res1 = 0 ;
45468 bool temp2 = false ;
45469 PyObject * obj0 = 0 ;
45470 PyObject * obj1 = 0 ;
45471 char * kwnames[] = {
45472 (char *) "self",(char *) "s", NULL
45473 };
45474
45475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45477 if (!SWIG_IsOK(res1)) {
45478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45479 }
45480 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45481 {
45482 arg2 = wxString_in_helper(obj1);
45483 if (arg2 == NULL) SWIG_fail;
45484 temp2 = true;
45485 }
45486 {
45487 PyThreadState* __tstate = wxPyBeginAllowThreads();
45488 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45489 wxPyEndAllowThreads(__tstate);
45490 if (PyErr_Occurred()) SWIG_fail;
45491 }
45492 resultobj = SWIG_From_int(static_cast< int >(result));
45493 {
45494 if (temp2)
45495 delete arg2;
45496 }
45497 return resultobj;
45498 fail:
45499 {
45500 if (temp2)
45501 delete arg2;
45502 }
45503 return NULL;
45504 }
45505
45506
45507 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45508 PyObject *resultobj = 0;
45509 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45510 int arg2 ;
45511 void *argp1 = 0 ;
45512 int res1 = 0 ;
45513 int val2 ;
45514 int ecode2 = 0 ;
45515 PyObject * obj0 = 0 ;
45516 PyObject * obj1 = 0 ;
45517 char * kwnames[] = {
45518 (char *) "self",(char *) "n", NULL
45519 };
45520
45521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45523 if (!SWIG_IsOK(res1)) {
45524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45525 }
45526 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45527 ecode2 = SWIG_AsVal_int(obj1, &val2);
45528 if (!SWIG_IsOK(ecode2)) {
45529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45530 }
45531 arg2 = static_cast< int >(val2);
45532 {
45533 PyThreadState* __tstate = wxPyBeginAllowThreads();
45534 (arg1)->SetSelection(arg2);
45535 wxPyEndAllowThreads(__tstate);
45536 if (PyErr_Occurred()) SWIG_fail;
45537 }
45538 resultobj = SWIG_Py_Void();
45539 return resultobj;
45540 fail:
45541 return NULL;
45542 }
45543
45544
45545 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45546 PyObject *resultobj = 0;
45547 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45548 int result;
45549 void *argp1 = 0 ;
45550 int res1 = 0 ;
45551 PyObject *swig_obj[1] ;
45552
45553 if (!args) SWIG_fail;
45554 swig_obj[0] = args;
45555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45556 if (!SWIG_IsOK(res1)) {
45557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45558 }
45559 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45560 {
45561 PyThreadState* __tstate = wxPyBeginAllowThreads();
45562 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45563 wxPyEndAllowThreads(__tstate);
45564 if (PyErr_Occurred()) SWIG_fail;
45565 }
45566 resultobj = SWIG_From_int(static_cast< int >(result));
45567 return resultobj;
45568 fail:
45569 return NULL;
45570 }
45571
45572
45573 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45574 PyObject *resultobj = 0;
45575 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45576 wxString *arg2 = 0 ;
45577 bool result;
45578 void *argp1 = 0 ;
45579 int res1 = 0 ;
45580 bool temp2 = false ;
45581 PyObject * obj0 = 0 ;
45582 PyObject * obj1 = 0 ;
45583 char * kwnames[] = {
45584 (char *) "self",(char *) "s", NULL
45585 };
45586
45587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45589 if (!SWIG_IsOK(res1)) {
45590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45591 }
45592 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45593 {
45594 arg2 = wxString_in_helper(obj1);
45595 if (arg2 == NULL) SWIG_fail;
45596 temp2 = true;
45597 }
45598 {
45599 PyThreadState* __tstate = wxPyBeginAllowThreads();
45600 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45601 wxPyEndAllowThreads(__tstate);
45602 if (PyErr_Occurred()) SWIG_fail;
45603 }
45604 {
45605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45606 }
45607 {
45608 if (temp2)
45609 delete arg2;
45610 }
45611 return resultobj;
45612 fail:
45613 {
45614 if (temp2)
45615 delete arg2;
45616 }
45617 return NULL;
45618 }
45619
45620
45621 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45622 PyObject *resultobj = 0;
45623 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45624 wxString result;
45625 void *argp1 = 0 ;
45626 int res1 = 0 ;
45627 PyObject *swig_obj[1] ;
45628
45629 if (!args) SWIG_fail;
45630 swig_obj[0] = args;
45631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45632 if (!SWIG_IsOK(res1)) {
45633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45634 }
45635 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45636 {
45637 PyThreadState* __tstate = wxPyBeginAllowThreads();
45638 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45639 wxPyEndAllowThreads(__tstate);
45640 if (PyErr_Occurred()) SWIG_fail;
45641 }
45642 {
45643 #if wxUSE_UNICODE
45644 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45645 #else
45646 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45647 #endif
45648 }
45649 return resultobj;
45650 fail:
45651 return NULL;
45652 }
45653
45654
45655 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45656 PyObject *resultobj = 0;
45657 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45658 int arg2 ;
45659 void *argp1 = 0 ;
45660 int res1 = 0 ;
45661 int val2 ;
45662 int ecode2 = 0 ;
45663 PyObject * obj0 = 0 ;
45664 PyObject * obj1 = 0 ;
45665 char * kwnames[] = {
45666 (char *) "self",(char *) "n", NULL
45667 };
45668
45669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45671 if (!SWIG_IsOK(res1)) {
45672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45673 }
45674 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45675 ecode2 = SWIG_AsVal_int(obj1, &val2);
45676 if (!SWIG_IsOK(ecode2)) {
45677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45678 }
45679 arg2 = static_cast< int >(val2);
45680 {
45681 PyThreadState* __tstate = wxPyBeginAllowThreads();
45682 (arg1)->Select(arg2);
45683 wxPyEndAllowThreads(__tstate);
45684 if (PyErr_Occurred()) SWIG_fail;
45685 }
45686 resultobj = SWIG_Py_Void();
45687 return resultobj;
45688 fail:
45689 return NULL;
45690 }
45691
45692
45693 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45694 PyObject *obj;
45695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45696 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45697 return SWIG_Py_Void();
45698 }
45699
45700 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45701 PyObject *obj;
45702 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45703 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45704 return SWIG_Py_Void();
45705 }
45706
45707 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45708 PyObject *resultobj = 0;
45709 wxSizerItem *result = 0 ;
45710
45711 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45712 {
45713 PyThreadState* __tstate = wxPyBeginAllowThreads();
45714 result = (wxSizerItem *)new wxSizerItem();
45715 wxPyEndAllowThreads(__tstate);
45716 if (PyErr_Occurred()) SWIG_fail;
45717 }
45718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45719 return resultobj;
45720 fail:
45721 return NULL;
45722 }
45723
45724
45725 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45726 PyObject *resultobj = 0;
45727 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45728 void *argp1 = 0 ;
45729 int res1 = 0 ;
45730 PyObject *swig_obj[1] ;
45731
45732 if (!args) SWIG_fail;
45733 swig_obj[0] = args;
45734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45735 if (!SWIG_IsOK(res1)) {
45736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45737 }
45738 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45739 {
45740 PyThreadState* __tstate = wxPyBeginAllowThreads();
45741 delete arg1;
45742
45743 wxPyEndAllowThreads(__tstate);
45744 if (PyErr_Occurred()) SWIG_fail;
45745 }
45746 resultobj = SWIG_Py_Void();
45747 return resultobj;
45748 fail:
45749 return NULL;
45750 }
45751
45752
45753 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45754 PyObject *resultobj = 0;
45755 wxWindow *arg1 = (wxWindow *) 0 ;
45756 int arg2 ;
45757 int arg3 ;
45758 int arg4 ;
45759 PyObject *arg5 = (PyObject *) NULL ;
45760 wxSizerItem *result = 0 ;
45761 void *argp1 = 0 ;
45762 int res1 = 0 ;
45763 int val2 ;
45764 int ecode2 = 0 ;
45765 int val3 ;
45766 int ecode3 = 0 ;
45767 int val4 ;
45768 int ecode4 = 0 ;
45769 PyObject * obj0 = 0 ;
45770 PyObject * obj1 = 0 ;
45771 PyObject * obj2 = 0 ;
45772 PyObject * obj3 = 0 ;
45773 PyObject * obj4 = 0 ;
45774 char * kwnames[] = {
45775 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45776 };
45777
45778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45780 if (!SWIG_IsOK(res1)) {
45781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45782 }
45783 arg1 = reinterpret_cast< wxWindow * >(argp1);
45784 ecode2 = SWIG_AsVal_int(obj1, &val2);
45785 if (!SWIG_IsOK(ecode2)) {
45786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45787 }
45788 arg2 = static_cast< int >(val2);
45789 ecode3 = SWIG_AsVal_int(obj2, &val3);
45790 if (!SWIG_IsOK(ecode3)) {
45791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45792 }
45793 arg3 = static_cast< int >(val3);
45794 ecode4 = SWIG_AsVal_int(obj3, &val4);
45795 if (!SWIG_IsOK(ecode4)) {
45796 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45797 }
45798 arg4 = static_cast< int >(val4);
45799 if (obj4) {
45800 arg5 = obj4;
45801 }
45802 {
45803 PyThreadState* __tstate = wxPyBeginAllowThreads();
45804 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45805 wxPyEndAllowThreads(__tstate);
45806 if (PyErr_Occurred()) SWIG_fail;
45807 }
45808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45809 return resultobj;
45810 fail:
45811 return NULL;
45812 }
45813
45814
45815 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45816 PyObject *resultobj = 0;
45817 int arg1 ;
45818 int arg2 ;
45819 int arg3 ;
45820 int arg4 ;
45821 int arg5 ;
45822 PyObject *arg6 = (PyObject *) NULL ;
45823 wxSizerItem *result = 0 ;
45824 int val1 ;
45825 int ecode1 = 0 ;
45826 int val2 ;
45827 int ecode2 = 0 ;
45828 int val3 ;
45829 int ecode3 = 0 ;
45830 int val4 ;
45831 int ecode4 = 0 ;
45832 int val5 ;
45833 int ecode5 = 0 ;
45834 PyObject * obj0 = 0 ;
45835 PyObject * obj1 = 0 ;
45836 PyObject * obj2 = 0 ;
45837 PyObject * obj3 = 0 ;
45838 PyObject * obj4 = 0 ;
45839 PyObject * obj5 = 0 ;
45840 char * kwnames[] = {
45841 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45842 };
45843
45844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45845 ecode1 = SWIG_AsVal_int(obj0, &val1);
45846 if (!SWIG_IsOK(ecode1)) {
45847 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45848 }
45849 arg1 = static_cast< int >(val1);
45850 ecode2 = SWIG_AsVal_int(obj1, &val2);
45851 if (!SWIG_IsOK(ecode2)) {
45852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45853 }
45854 arg2 = static_cast< int >(val2);
45855 ecode3 = SWIG_AsVal_int(obj2, &val3);
45856 if (!SWIG_IsOK(ecode3)) {
45857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45858 }
45859 arg3 = static_cast< int >(val3);
45860 ecode4 = SWIG_AsVal_int(obj3, &val4);
45861 if (!SWIG_IsOK(ecode4)) {
45862 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45863 }
45864 arg4 = static_cast< int >(val4);
45865 ecode5 = SWIG_AsVal_int(obj4, &val5);
45866 if (!SWIG_IsOK(ecode5)) {
45867 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45868 }
45869 arg5 = static_cast< int >(val5);
45870 if (obj5) {
45871 arg6 = obj5;
45872 }
45873 {
45874 PyThreadState* __tstate = wxPyBeginAllowThreads();
45875 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45876 wxPyEndAllowThreads(__tstate);
45877 if (PyErr_Occurred()) SWIG_fail;
45878 }
45879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45880 return resultobj;
45881 fail:
45882 return NULL;
45883 }
45884
45885
45886 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45887 PyObject *resultobj = 0;
45888 wxSizer *arg1 = (wxSizer *) 0 ;
45889 int arg2 ;
45890 int arg3 ;
45891 int arg4 ;
45892 PyObject *arg5 = (PyObject *) NULL ;
45893 wxSizerItem *result = 0 ;
45894 int res1 = 0 ;
45895 int val2 ;
45896 int ecode2 = 0 ;
45897 int val3 ;
45898 int ecode3 = 0 ;
45899 int val4 ;
45900 int ecode4 = 0 ;
45901 PyObject * obj0 = 0 ;
45902 PyObject * obj1 = 0 ;
45903 PyObject * obj2 = 0 ;
45904 PyObject * obj3 = 0 ;
45905 PyObject * obj4 = 0 ;
45906 char * kwnames[] = {
45907 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45908 };
45909
45910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45911 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45912 if (!SWIG_IsOK(res1)) {
45913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45914 }
45915 ecode2 = SWIG_AsVal_int(obj1, &val2);
45916 if (!SWIG_IsOK(ecode2)) {
45917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45918 }
45919 arg2 = static_cast< int >(val2);
45920 ecode3 = SWIG_AsVal_int(obj2, &val3);
45921 if (!SWIG_IsOK(ecode3)) {
45922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45923 }
45924 arg3 = static_cast< int >(val3);
45925 ecode4 = SWIG_AsVal_int(obj3, &val4);
45926 if (!SWIG_IsOK(ecode4)) {
45927 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45928 }
45929 arg4 = static_cast< int >(val4);
45930 if (obj4) {
45931 arg5 = obj4;
45932 }
45933 {
45934 PyThreadState* __tstate = wxPyBeginAllowThreads();
45935 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45936 wxPyEndAllowThreads(__tstate);
45937 if (PyErr_Occurred()) SWIG_fail;
45938 }
45939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45940 return resultobj;
45941 fail:
45942 return NULL;
45943 }
45944
45945
45946 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45947 PyObject *resultobj = 0;
45948 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45949 void *argp1 = 0 ;
45950 int res1 = 0 ;
45951 PyObject *swig_obj[1] ;
45952
45953 if (!args) SWIG_fail;
45954 swig_obj[0] = args;
45955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45956 if (!SWIG_IsOK(res1)) {
45957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45958 }
45959 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45960 {
45961 PyThreadState* __tstate = wxPyBeginAllowThreads();
45962 (arg1)->DeleteWindows();
45963 wxPyEndAllowThreads(__tstate);
45964 if (PyErr_Occurred()) SWIG_fail;
45965 }
45966 resultobj = SWIG_Py_Void();
45967 return resultobj;
45968 fail:
45969 return NULL;
45970 }
45971
45972
45973 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45974 PyObject *resultobj = 0;
45975 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45976 void *argp1 = 0 ;
45977 int res1 = 0 ;
45978 PyObject *swig_obj[1] ;
45979
45980 if (!args) SWIG_fail;
45981 swig_obj[0] = args;
45982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45983 if (!SWIG_IsOK(res1)) {
45984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45985 }
45986 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45987 {
45988 PyThreadState* __tstate = wxPyBeginAllowThreads();
45989 (arg1)->DetachSizer();
45990 wxPyEndAllowThreads(__tstate);
45991 if (PyErr_Occurred()) SWIG_fail;
45992 }
45993 resultobj = SWIG_Py_Void();
45994 return resultobj;
45995 fail:
45996 return NULL;
45997 }
45998
45999
46000 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46001 PyObject *resultobj = 0;
46002 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46003 wxSize result;
46004 void *argp1 = 0 ;
46005 int res1 = 0 ;
46006 PyObject *swig_obj[1] ;
46007
46008 if (!args) SWIG_fail;
46009 swig_obj[0] = args;
46010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46011 if (!SWIG_IsOK(res1)) {
46012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46013 }
46014 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46015 {
46016 PyThreadState* __tstate = wxPyBeginAllowThreads();
46017 result = (arg1)->GetSize();
46018 wxPyEndAllowThreads(__tstate);
46019 if (PyErr_Occurred()) SWIG_fail;
46020 }
46021 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46022 return resultobj;
46023 fail:
46024 return NULL;
46025 }
46026
46027
46028 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46029 PyObject *resultobj = 0;
46030 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46031 wxSize result;
46032 void *argp1 = 0 ;
46033 int res1 = 0 ;
46034 PyObject *swig_obj[1] ;
46035
46036 if (!args) SWIG_fail;
46037 swig_obj[0] = args;
46038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46039 if (!SWIG_IsOK(res1)) {
46040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46041 }
46042 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46043 {
46044 PyThreadState* __tstate = wxPyBeginAllowThreads();
46045 result = (arg1)->CalcMin();
46046 wxPyEndAllowThreads(__tstate);
46047 if (PyErr_Occurred()) SWIG_fail;
46048 }
46049 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46050 return resultobj;
46051 fail:
46052 return NULL;
46053 }
46054
46055
46056 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46057 PyObject *resultobj = 0;
46058 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46059 wxPoint *arg2 = 0 ;
46060 wxSize *arg3 = 0 ;
46061 void *argp1 = 0 ;
46062 int res1 = 0 ;
46063 wxPoint temp2 ;
46064 wxSize temp3 ;
46065 PyObject * obj0 = 0 ;
46066 PyObject * obj1 = 0 ;
46067 PyObject * obj2 = 0 ;
46068 char * kwnames[] = {
46069 (char *) "self",(char *) "pos",(char *) "size", NULL
46070 };
46071
46072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46074 if (!SWIG_IsOK(res1)) {
46075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46076 }
46077 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46078 {
46079 arg2 = &temp2;
46080 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46081 }
46082 {
46083 arg3 = &temp3;
46084 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46085 }
46086 {
46087 PyThreadState* __tstate = wxPyBeginAllowThreads();
46088 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46089 wxPyEndAllowThreads(__tstate);
46090 if (PyErr_Occurred()) SWIG_fail;
46091 }
46092 resultobj = SWIG_Py_Void();
46093 return resultobj;
46094 fail:
46095 return NULL;
46096 }
46097
46098
46099 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46100 PyObject *resultobj = 0;
46101 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46102 wxSize result;
46103 void *argp1 = 0 ;
46104 int res1 = 0 ;
46105 PyObject *swig_obj[1] ;
46106
46107 if (!args) SWIG_fail;
46108 swig_obj[0] = args;
46109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46110 if (!SWIG_IsOK(res1)) {
46111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46112 }
46113 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46114 {
46115 PyThreadState* __tstate = wxPyBeginAllowThreads();
46116 result = (arg1)->GetMinSize();
46117 wxPyEndAllowThreads(__tstate);
46118 if (PyErr_Occurred()) SWIG_fail;
46119 }
46120 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46121 return resultobj;
46122 fail:
46123 return NULL;
46124 }
46125
46126
46127 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46128 PyObject *resultobj = 0;
46129 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46130 wxSize result;
46131 void *argp1 = 0 ;
46132 int res1 = 0 ;
46133 PyObject *swig_obj[1] ;
46134
46135 if (!args) SWIG_fail;
46136 swig_obj[0] = args;
46137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46138 if (!SWIG_IsOK(res1)) {
46139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46140 }
46141 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46142 {
46143 PyThreadState* __tstate = wxPyBeginAllowThreads();
46144 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46145 wxPyEndAllowThreads(__tstate);
46146 if (PyErr_Occurred()) SWIG_fail;
46147 }
46148 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46149 return resultobj;
46150 fail:
46151 return NULL;
46152 }
46153
46154
46155 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46156 PyObject *resultobj = 0;
46157 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46158 int arg2 ;
46159 int arg3 ;
46160 void *argp1 = 0 ;
46161 int res1 = 0 ;
46162 int val2 ;
46163 int ecode2 = 0 ;
46164 int val3 ;
46165 int ecode3 = 0 ;
46166 PyObject * obj0 = 0 ;
46167 PyObject * obj1 = 0 ;
46168 PyObject * obj2 = 0 ;
46169 char * kwnames[] = {
46170 (char *) "self",(char *) "x",(char *) "y", NULL
46171 };
46172
46173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46175 if (!SWIG_IsOK(res1)) {
46176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46177 }
46178 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46179 ecode2 = SWIG_AsVal_int(obj1, &val2);
46180 if (!SWIG_IsOK(ecode2)) {
46181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46182 }
46183 arg2 = static_cast< int >(val2);
46184 ecode3 = SWIG_AsVal_int(obj2, &val3);
46185 if (!SWIG_IsOK(ecode3)) {
46186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46187 }
46188 arg3 = static_cast< int >(val3);
46189 {
46190 PyThreadState* __tstate = wxPyBeginAllowThreads();
46191 (arg1)->SetInitSize(arg2,arg3);
46192 wxPyEndAllowThreads(__tstate);
46193 if (PyErr_Occurred()) SWIG_fail;
46194 }
46195 resultobj = SWIG_Py_Void();
46196 return resultobj;
46197 fail:
46198 return NULL;
46199 }
46200
46201
46202 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46203 PyObject *resultobj = 0;
46204 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46205 int arg2 ;
46206 int arg3 ;
46207 void *argp1 = 0 ;
46208 int res1 = 0 ;
46209 int val2 ;
46210 int ecode2 = 0 ;
46211 int val3 ;
46212 int ecode3 = 0 ;
46213 PyObject * obj0 = 0 ;
46214 PyObject * obj1 = 0 ;
46215 PyObject * obj2 = 0 ;
46216 char * kwnames[] = {
46217 (char *) "self",(char *) "width",(char *) "height", NULL
46218 };
46219
46220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46222 if (!SWIG_IsOK(res1)) {
46223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46224 }
46225 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46226 ecode2 = SWIG_AsVal_int(obj1, &val2);
46227 if (!SWIG_IsOK(ecode2)) {
46228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46229 }
46230 arg2 = static_cast< int >(val2);
46231 ecode3 = SWIG_AsVal_int(obj2, &val3);
46232 if (!SWIG_IsOK(ecode3)) {
46233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46234 }
46235 arg3 = static_cast< int >(val3);
46236 {
46237 PyThreadState* __tstate = wxPyBeginAllowThreads();
46238 (arg1)->SetRatio(arg2,arg3);
46239 wxPyEndAllowThreads(__tstate);
46240 if (PyErr_Occurred()) SWIG_fail;
46241 }
46242 resultobj = SWIG_Py_Void();
46243 return resultobj;
46244 fail:
46245 return NULL;
46246 }
46247
46248
46249 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46250 PyObject *resultobj = 0;
46251 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46252 wxSize *arg2 = 0 ;
46253 void *argp1 = 0 ;
46254 int res1 = 0 ;
46255 wxSize temp2 ;
46256 PyObject * obj0 = 0 ;
46257 PyObject * obj1 = 0 ;
46258 char * kwnames[] = {
46259 (char *) "self",(char *) "size", NULL
46260 };
46261
46262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46264 if (!SWIG_IsOK(res1)) {
46265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46266 }
46267 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46268 {
46269 arg2 = &temp2;
46270 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46271 }
46272 {
46273 PyThreadState* __tstate = wxPyBeginAllowThreads();
46274 (arg1)->SetRatio((wxSize const &)*arg2);
46275 wxPyEndAllowThreads(__tstate);
46276 if (PyErr_Occurred()) SWIG_fail;
46277 }
46278 resultobj = SWIG_Py_Void();
46279 return resultobj;
46280 fail:
46281 return NULL;
46282 }
46283
46284
46285 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46286 PyObject *resultobj = 0;
46287 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46288 float arg2 ;
46289 void *argp1 = 0 ;
46290 int res1 = 0 ;
46291 float val2 ;
46292 int ecode2 = 0 ;
46293 PyObject * obj0 = 0 ;
46294 PyObject * obj1 = 0 ;
46295 char * kwnames[] = {
46296 (char *) "self",(char *) "ratio", NULL
46297 };
46298
46299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46301 if (!SWIG_IsOK(res1)) {
46302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46303 }
46304 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46305 ecode2 = SWIG_AsVal_float(obj1, &val2);
46306 if (!SWIG_IsOK(ecode2)) {
46307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46308 }
46309 arg2 = static_cast< float >(val2);
46310 {
46311 PyThreadState* __tstate = wxPyBeginAllowThreads();
46312 (arg1)->SetRatio(arg2);
46313 wxPyEndAllowThreads(__tstate);
46314 if (PyErr_Occurred()) SWIG_fail;
46315 }
46316 resultobj = SWIG_Py_Void();
46317 return resultobj;
46318 fail:
46319 return NULL;
46320 }
46321
46322
46323 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46324 PyObject *resultobj = 0;
46325 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46326 float result;
46327 void *argp1 = 0 ;
46328 int res1 = 0 ;
46329 PyObject *swig_obj[1] ;
46330
46331 if (!args) SWIG_fail;
46332 swig_obj[0] = args;
46333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46334 if (!SWIG_IsOK(res1)) {
46335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46336 }
46337 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46338 {
46339 PyThreadState* __tstate = wxPyBeginAllowThreads();
46340 result = (float)(arg1)->GetRatio();
46341 wxPyEndAllowThreads(__tstate);
46342 if (PyErr_Occurred()) SWIG_fail;
46343 }
46344 resultobj = SWIG_From_float(static_cast< float >(result));
46345 return resultobj;
46346 fail:
46347 return NULL;
46348 }
46349
46350
46351 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46352 PyObject *resultobj = 0;
46353 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46354 wxRect result;
46355 void *argp1 = 0 ;
46356 int res1 = 0 ;
46357 PyObject *swig_obj[1] ;
46358
46359 if (!args) SWIG_fail;
46360 swig_obj[0] = args;
46361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46362 if (!SWIG_IsOK(res1)) {
46363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46364 }
46365 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46366 {
46367 PyThreadState* __tstate = wxPyBeginAllowThreads();
46368 result = (arg1)->GetRect();
46369 wxPyEndAllowThreads(__tstate);
46370 if (PyErr_Occurred()) SWIG_fail;
46371 }
46372 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46373 return resultobj;
46374 fail:
46375 return NULL;
46376 }
46377
46378
46379 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46380 PyObject *resultobj = 0;
46381 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46382 bool result;
46383 void *argp1 = 0 ;
46384 int res1 = 0 ;
46385 PyObject *swig_obj[1] ;
46386
46387 if (!args) SWIG_fail;
46388 swig_obj[0] = args;
46389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46390 if (!SWIG_IsOK(res1)) {
46391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46392 }
46393 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46394 {
46395 PyThreadState* __tstate = wxPyBeginAllowThreads();
46396 result = (bool)(arg1)->IsWindow();
46397 wxPyEndAllowThreads(__tstate);
46398 if (PyErr_Occurred()) SWIG_fail;
46399 }
46400 {
46401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46402 }
46403 return resultobj;
46404 fail:
46405 return NULL;
46406 }
46407
46408
46409 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46410 PyObject *resultobj = 0;
46411 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46412 bool result;
46413 void *argp1 = 0 ;
46414 int res1 = 0 ;
46415 PyObject *swig_obj[1] ;
46416
46417 if (!args) SWIG_fail;
46418 swig_obj[0] = args;
46419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46420 if (!SWIG_IsOK(res1)) {
46421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46422 }
46423 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46424 {
46425 PyThreadState* __tstate = wxPyBeginAllowThreads();
46426 result = (bool)(arg1)->IsSizer();
46427 wxPyEndAllowThreads(__tstate);
46428 if (PyErr_Occurred()) SWIG_fail;
46429 }
46430 {
46431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46432 }
46433 return resultobj;
46434 fail:
46435 return NULL;
46436 }
46437
46438
46439 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46440 PyObject *resultobj = 0;
46441 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46442 bool result;
46443 void *argp1 = 0 ;
46444 int res1 = 0 ;
46445 PyObject *swig_obj[1] ;
46446
46447 if (!args) SWIG_fail;
46448 swig_obj[0] = args;
46449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46450 if (!SWIG_IsOK(res1)) {
46451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46452 }
46453 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46454 {
46455 PyThreadState* __tstate = wxPyBeginAllowThreads();
46456 result = (bool)(arg1)->IsSpacer();
46457 wxPyEndAllowThreads(__tstate);
46458 if (PyErr_Occurred()) SWIG_fail;
46459 }
46460 {
46461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46462 }
46463 return resultobj;
46464 fail:
46465 return NULL;
46466 }
46467
46468
46469 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46470 PyObject *resultobj = 0;
46471 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46472 int arg2 ;
46473 void *argp1 = 0 ;
46474 int res1 = 0 ;
46475 int val2 ;
46476 int ecode2 = 0 ;
46477 PyObject * obj0 = 0 ;
46478 PyObject * obj1 = 0 ;
46479 char * kwnames[] = {
46480 (char *) "self",(char *) "proportion", NULL
46481 };
46482
46483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46485 if (!SWIG_IsOK(res1)) {
46486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46487 }
46488 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46489 ecode2 = SWIG_AsVal_int(obj1, &val2);
46490 if (!SWIG_IsOK(ecode2)) {
46491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46492 }
46493 arg2 = static_cast< int >(val2);
46494 {
46495 PyThreadState* __tstate = wxPyBeginAllowThreads();
46496 (arg1)->SetProportion(arg2);
46497 wxPyEndAllowThreads(__tstate);
46498 if (PyErr_Occurred()) SWIG_fail;
46499 }
46500 resultobj = SWIG_Py_Void();
46501 return resultobj;
46502 fail:
46503 return NULL;
46504 }
46505
46506
46507 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46508 PyObject *resultobj = 0;
46509 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46510 int result;
46511 void *argp1 = 0 ;
46512 int res1 = 0 ;
46513 PyObject *swig_obj[1] ;
46514
46515 if (!args) SWIG_fail;
46516 swig_obj[0] = args;
46517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46518 if (!SWIG_IsOK(res1)) {
46519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46520 }
46521 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46522 {
46523 PyThreadState* __tstate = wxPyBeginAllowThreads();
46524 result = (int)(arg1)->GetProportion();
46525 wxPyEndAllowThreads(__tstate);
46526 if (PyErr_Occurred()) SWIG_fail;
46527 }
46528 resultobj = SWIG_From_int(static_cast< int >(result));
46529 return resultobj;
46530 fail:
46531 return NULL;
46532 }
46533
46534
46535 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46536 PyObject *resultobj = 0;
46537 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46538 int arg2 ;
46539 void *argp1 = 0 ;
46540 int res1 = 0 ;
46541 int val2 ;
46542 int ecode2 = 0 ;
46543 PyObject * obj0 = 0 ;
46544 PyObject * obj1 = 0 ;
46545 char * kwnames[] = {
46546 (char *) "self",(char *) "flag", NULL
46547 };
46548
46549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46551 if (!SWIG_IsOK(res1)) {
46552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46553 }
46554 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46555 ecode2 = SWIG_AsVal_int(obj1, &val2);
46556 if (!SWIG_IsOK(ecode2)) {
46557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46558 }
46559 arg2 = static_cast< int >(val2);
46560 {
46561 PyThreadState* __tstate = wxPyBeginAllowThreads();
46562 (arg1)->SetFlag(arg2);
46563 wxPyEndAllowThreads(__tstate);
46564 if (PyErr_Occurred()) SWIG_fail;
46565 }
46566 resultobj = SWIG_Py_Void();
46567 return resultobj;
46568 fail:
46569 return NULL;
46570 }
46571
46572
46573 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46574 PyObject *resultobj = 0;
46575 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46576 int result;
46577 void *argp1 = 0 ;
46578 int res1 = 0 ;
46579 PyObject *swig_obj[1] ;
46580
46581 if (!args) SWIG_fail;
46582 swig_obj[0] = args;
46583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46584 if (!SWIG_IsOK(res1)) {
46585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46586 }
46587 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46588 {
46589 PyThreadState* __tstate = wxPyBeginAllowThreads();
46590 result = (int)(arg1)->GetFlag();
46591 wxPyEndAllowThreads(__tstate);
46592 if (PyErr_Occurred()) SWIG_fail;
46593 }
46594 resultobj = SWIG_From_int(static_cast< int >(result));
46595 return resultobj;
46596 fail:
46597 return NULL;
46598 }
46599
46600
46601 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46602 PyObject *resultobj = 0;
46603 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46604 int arg2 ;
46605 void *argp1 = 0 ;
46606 int res1 = 0 ;
46607 int val2 ;
46608 int ecode2 = 0 ;
46609 PyObject * obj0 = 0 ;
46610 PyObject * obj1 = 0 ;
46611 char * kwnames[] = {
46612 (char *) "self",(char *) "border", NULL
46613 };
46614
46615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46617 if (!SWIG_IsOK(res1)) {
46618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46619 }
46620 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46621 ecode2 = SWIG_AsVal_int(obj1, &val2);
46622 if (!SWIG_IsOK(ecode2)) {
46623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46624 }
46625 arg2 = static_cast< int >(val2);
46626 {
46627 PyThreadState* __tstate = wxPyBeginAllowThreads();
46628 (arg1)->SetBorder(arg2);
46629 wxPyEndAllowThreads(__tstate);
46630 if (PyErr_Occurred()) SWIG_fail;
46631 }
46632 resultobj = SWIG_Py_Void();
46633 return resultobj;
46634 fail:
46635 return NULL;
46636 }
46637
46638
46639 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46640 PyObject *resultobj = 0;
46641 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46642 int result;
46643 void *argp1 = 0 ;
46644 int res1 = 0 ;
46645 PyObject *swig_obj[1] ;
46646
46647 if (!args) SWIG_fail;
46648 swig_obj[0] = args;
46649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46650 if (!SWIG_IsOK(res1)) {
46651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46652 }
46653 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46654 {
46655 PyThreadState* __tstate = wxPyBeginAllowThreads();
46656 result = (int)(arg1)->GetBorder();
46657 wxPyEndAllowThreads(__tstate);
46658 if (PyErr_Occurred()) SWIG_fail;
46659 }
46660 resultobj = SWIG_From_int(static_cast< int >(result));
46661 return resultobj;
46662 fail:
46663 return NULL;
46664 }
46665
46666
46667 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46668 PyObject *resultobj = 0;
46669 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46670 wxWindow *result = 0 ;
46671 void *argp1 = 0 ;
46672 int res1 = 0 ;
46673 PyObject *swig_obj[1] ;
46674
46675 if (!args) SWIG_fail;
46676 swig_obj[0] = args;
46677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46678 if (!SWIG_IsOK(res1)) {
46679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46680 }
46681 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46682 {
46683 PyThreadState* __tstate = wxPyBeginAllowThreads();
46684 result = (wxWindow *)(arg1)->GetWindow();
46685 wxPyEndAllowThreads(__tstate);
46686 if (PyErr_Occurred()) SWIG_fail;
46687 }
46688 {
46689 resultobj = wxPyMake_wxObject(result, 0);
46690 }
46691 return resultobj;
46692 fail:
46693 return NULL;
46694 }
46695
46696
46697 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46698 PyObject *resultobj = 0;
46699 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46700 wxWindow *arg2 = (wxWindow *) 0 ;
46701 void *argp1 = 0 ;
46702 int res1 = 0 ;
46703 void *argp2 = 0 ;
46704 int res2 = 0 ;
46705 PyObject * obj0 = 0 ;
46706 PyObject * obj1 = 0 ;
46707 char * kwnames[] = {
46708 (char *) "self",(char *) "window", NULL
46709 };
46710
46711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46713 if (!SWIG_IsOK(res1)) {
46714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46715 }
46716 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46717 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46718 if (!SWIG_IsOK(res2)) {
46719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46720 }
46721 arg2 = reinterpret_cast< wxWindow * >(argp2);
46722 {
46723 PyThreadState* __tstate = wxPyBeginAllowThreads();
46724 (arg1)->SetWindow(arg2);
46725 wxPyEndAllowThreads(__tstate);
46726 if (PyErr_Occurred()) SWIG_fail;
46727 }
46728 resultobj = SWIG_Py_Void();
46729 return resultobj;
46730 fail:
46731 return NULL;
46732 }
46733
46734
46735 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46736 PyObject *resultobj = 0;
46737 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46738 wxSizer *result = 0 ;
46739 void *argp1 = 0 ;
46740 int res1 = 0 ;
46741 PyObject *swig_obj[1] ;
46742
46743 if (!args) SWIG_fail;
46744 swig_obj[0] = args;
46745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46746 if (!SWIG_IsOK(res1)) {
46747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46748 }
46749 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46750 {
46751 PyThreadState* __tstate = wxPyBeginAllowThreads();
46752 result = (wxSizer *)(arg1)->GetSizer();
46753 wxPyEndAllowThreads(__tstate);
46754 if (PyErr_Occurred()) SWIG_fail;
46755 }
46756 {
46757 resultobj = wxPyMake_wxObject(result, (bool)0);
46758 }
46759 return resultobj;
46760 fail:
46761 return NULL;
46762 }
46763
46764
46765 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46766 PyObject *resultobj = 0;
46767 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46768 wxSizer *arg2 = (wxSizer *) 0 ;
46769 void *argp1 = 0 ;
46770 int res1 = 0 ;
46771 int res2 = 0 ;
46772 PyObject * obj0 = 0 ;
46773 PyObject * obj1 = 0 ;
46774 char * kwnames[] = {
46775 (char *) "self",(char *) "sizer", NULL
46776 };
46777
46778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46780 if (!SWIG_IsOK(res1)) {
46781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46782 }
46783 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46784 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46785 if (!SWIG_IsOK(res2)) {
46786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46787 }
46788 {
46789 PyThreadState* __tstate = wxPyBeginAllowThreads();
46790 (arg1)->SetSizer(arg2);
46791 wxPyEndAllowThreads(__tstate);
46792 if (PyErr_Occurred()) SWIG_fail;
46793 }
46794 resultobj = SWIG_Py_Void();
46795 return resultobj;
46796 fail:
46797 return NULL;
46798 }
46799
46800
46801 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46802 PyObject *resultobj = 0;
46803 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46804 wxSize *result = 0 ;
46805 void *argp1 = 0 ;
46806 int res1 = 0 ;
46807 PyObject *swig_obj[1] ;
46808
46809 if (!args) SWIG_fail;
46810 swig_obj[0] = args;
46811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46812 if (!SWIG_IsOK(res1)) {
46813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46814 }
46815 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46816 {
46817 PyThreadState* __tstate = wxPyBeginAllowThreads();
46818 {
46819 wxSize const &_result_ref = (arg1)->GetSpacer();
46820 result = (wxSize *) &_result_ref;
46821 }
46822 wxPyEndAllowThreads(__tstate);
46823 if (PyErr_Occurred()) SWIG_fail;
46824 }
46825 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46826 return resultobj;
46827 fail:
46828 return NULL;
46829 }
46830
46831
46832 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46833 PyObject *resultobj = 0;
46834 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46835 wxSize *arg2 = 0 ;
46836 void *argp1 = 0 ;
46837 int res1 = 0 ;
46838 wxSize temp2 ;
46839 PyObject * obj0 = 0 ;
46840 PyObject * obj1 = 0 ;
46841 char * kwnames[] = {
46842 (char *) "self",(char *) "size", NULL
46843 };
46844
46845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46847 if (!SWIG_IsOK(res1)) {
46848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46849 }
46850 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46851 {
46852 arg2 = &temp2;
46853 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46854 }
46855 {
46856 PyThreadState* __tstate = wxPyBeginAllowThreads();
46857 (arg1)->SetSpacer((wxSize const &)*arg2);
46858 wxPyEndAllowThreads(__tstate);
46859 if (PyErr_Occurred()) SWIG_fail;
46860 }
46861 resultobj = SWIG_Py_Void();
46862 return resultobj;
46863 fail:
46864 return NULL;
46865 }
46866
46867
46868 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46869 PyObject *resultobj = 0;
46870 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46871 bool arg2 ;
46872 void *argp1 = 0 ;
46873 int res1 = 0 ;
46874 bool val2 ;
46875 int ecode2 = 0 ;
46876 PyObject * obj0 = 0 ;
46877 PyObject * obj1 = 0 ;
46878 char * kwnames[] = {
46879 (char *) "self",(char *) "show", NULL
46880 };
46881
46882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46884 if (!SWIG_IsOK(res1)) {
46885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46886 }
46887 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46888 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46889 if (!SWIG_IsOK(ecode2)) {
46890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46891 }
46892 arg2 = static_cast< bool >(val2);
46893 {
46894 PyThreadState* __tstate = wxPyBeginAllowThreads();
46895 (arg1)->Show(arg2);
46896 wxPyEndAllowThreads(__tstate);
46897 if (PyErr_Occurred()) SWIG_fail;
46898 }
46899 resultobj = SWIG_Py_Void();
46900 return resultobj;
46901 fail:
46902 return NULL;
46903 }
46904
46905
46906 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46907 PyObject *resultobj = 0;
46908 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46909 bool result;
46910 void *argp1 = 0 ;
46911 int res1 = 0 ;
46912 PyObject *swig_obj[1] ;
46913
46914 if (!args) SWIG_fail;
46915 swig_obj[0] = args;
46916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46917 if (!SWIG_IsOK(res1)) {
46918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46919 }
46920 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46921 {
46922 PyThreadState* __tstate = wxPyBeginAllowThreads();
46923 result = (bool)(arg1)->IsShown();
46924 wxPyEndAllowThreads(__tstate);
46925 if (PyErr_Occurred()) SWIG_fail;
46926 }
46927 {
46928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46929 }
46930 return resultobj;
46931 fail:
46932 return NULL;
46933 }
46934
46935
46936 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46937 PyObject *resultobj = 0;
46938 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46939 wxPoint result;
46940 void *argp1 = 0 ;
46941 int res1 = 0 ;
46942 PyObject *swig_obj[1] ;
46943
46944 if (!args) SWIG_fail;
46945 swig_obj[0] = args;
46946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46947 if (!SWIG_IsOK(res1)) {
46948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46949 }
46950 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46951 {
46952 PyThreadState* __tstate = wxPyBeginAllowThreads();
46953 result = (arg1)->GetPosition();
46954 wxPyEndAllowThreads(__tstate);
46955 if (PyErr_Occurred()) SWIG_fail;
46956 }
46957 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46958 return resultobj;
46959 fail:
46960 return NULL;
46961 }
46962
46963
46964 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46965 PyObject *resultobj = 0;
46966 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46967 PyObject *result = 0 ;
46968 void *argp1 = 0 ;
46969 int res1 = 0 ;
46970 PyObject *swig_obj[1] ;
46971
46972 if (!args) SWIG_fail;
46973 swig_obj[0] = args;
46974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46975 if (!SWIG_IsOK(res1)) {
46976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46977 }
46978 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46979 {
46980 PyThreadState* __tstate = wxPyBeginAllowThreads();
46981 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46982 wxPyEndAllowThreads(__tstate);
46983 if (PyErr_Occurred()) SWIG_fail;
46984 }
46985 resultobj = result;
46986 return resultobj;
46987 fail:
46988 return NULL;
46989 }
46990
46991
46992 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46993 PyObject *resultobj = 0;
46994 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46995 PyObject *arg2 = (PyObject *) 0 ;
46996 void *argp1 = 0 ;
46997 int res1 = 0 ;
46998 PyObject * obj0 = 0 ;
46999 PyObject * obj1 = 0 ;
47000 char * kwnames[] = {
47001 (char *) "self",(char *) "userData", NULL
47002 };
47003
47004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
47005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47006 if (!SWIG_IsOK(res1)) {
47007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
47008 }
47009 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
47010 arg2 = obj1;
47011 {
47012 PyThreadState* __tstate = wxPyBeginAllowThreads();
47013 wxSizerItem_SetUserData(arg1,arg2);
47014 wxPyEndAllowThreads(__tstate);
47015 if (PyErr_Occurred()) SWIG_fail;
47016 }
47017 resultobj = SWIG_Py_Void();
47018 return resultobj;
47019 fail:
47020 return NULL;
47021 }
47022
47023
47024 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47025 PyObject *obj;
47026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47027 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47028 return SWIG_Py_Void();
47029 }
47030
47031 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47032 return SWIG_Python_InitShadowInstance(args);
47033 }
47034
47035 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47036 PyObject *resultobj = 0;
47037 wxSizer *arg1 = (wxSizer *) 0 ;
47038 void *argp1 = 0 ;
47039 int res1 = 0 ;
47040 PyObject *swig_obj[1] ;
47041
47042 if (!args) SWIG_fail;
47043 swig_obj[0] = args;
47044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47045 if (!SWIG_IsOK(res1)) {
47046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47047 }
47048 arg1 = reinterpret_cast< wxSizer * >(argp1);
47049 {
47050 PyThreadState* __tstate = wxPyBeginAllowThreads();
47051 delete arg1;
47052
47053 wxPyEndAllowThreads(__tstate);
47054 if (PyErr_Occurred()) SWIG_fail;
47055 }
47056 resultobj = SWIG_Py_Void();
47057 return resultobj;
47058 fail:
47059 return NULL;
47060 }
47061
47062
47063 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47064 PyObject *resultobj = 0;
47065 wxSizer *arg1 = (wxSizer *) 0 ;
47066 PyObject *arg2 = (PyObject *) 0 ;
47067 void *argp1 = 0 ;
47068 int res1 = 0 ;
47069 PyObject * obj0 = 0 ;
47070 PyObject * obj1 = 0 ;
47071 char * kwnames[] = {
47072 (char *) "self",(char *) "_self", NULL
47073 };
47074
47075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47077 if (!SWIG_IsOK(res1)) {
47078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47079 }
47080 arg1 = reinterpret_cast< wxSizer * >(argp1);
47081 arg2 = obj1;
47082 {
47083 PyThreadState* __tstate = wxPyBeginAllowThreads();
47084 wxSizer__setOORInfo(arg1,arg2);
47085 wxPyEndAllowThreads(__tstate);
47086 if (PyErr_Occurred()) SWIG_fail;
47087 }
47088 resultobj = SWIG_Py_Void();
47089 return resultobj;
47090 fail:
47091 return NULL;
47092 }
47093
47094
47095 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47096 PyObject *resultobj = 0;
47097 wxSizer *arg1 = (wxSizer *) 0 ;
47098 PyObject *arg2 = (PyObject *) 0 ;
47099 int arg3 = (int) 0 ;
47100 int arg4 = (int) 0 ;
47101 int arg5 = (int) 0 ;
47102 PyObject *arg6 = (PyObject *) NULL ;
47103 wxSizerItem *result = 0 ;
47104 void *argp1 = 0 ;
47105 int res1 = 0 ;
47106 int val3 ;
47107 int ecode3 = 0 ;
47108 int val4 ;
47109 int ecode4 = 0 ;
47110 int val5 ;
47111 int ecode5 = 0 ;
47112 PyObject * obj0 = 0 ;
47113 PyObject * obj1 = 0 ;
47114 PyObject * obj2 = 0 ;
47115 PyObject * obj3 = 0 ;
47116 PyObject * obj4 = 0 ;
47117 PyObject * obj5 = 0 ;
47118 char * kwnames[] = {
47119 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47120 };
47121
47122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47124 if (!SWIG_IsOK(res1)) {
47125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47126 }
47127 arg1 = reinterpret_cast< wxSizer * >(argp1);
47128 arg2 = obj1;
47129 if (obj2) {
47130 ecode3 = SWIG_AsVal_int(obj2, &val3);
47131 if (!SWIG_IsOK(ecode3)) {
47132 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47133 }
47134 arg3 = static_cast< int >(val3);
47135 }
47136 if (obj3) {
47137 ecode4 = SWIG_AsVal_int(obj3, &val4);
47138 if (!SWIG_IsOK(ecode4)) {
47139 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47140 }
47141 arg4 = static_cast< int >(val4);
47142 }
47143 if (obj4) {
47144 ecode5 = SWIG_AsVal_int(obj4, &val5);
47145 if (!SWIG_IsOK(ecode5)) {
47146 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47147 }
47148 arg5 = static_cast< int >(val5);
47149 }
47150 if (obj5) {
47151 arg6 = obj5;
47152 }
47153 {
47154 PyThreadState* __tstate = wxPyBeginAllowThreads();
47155 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47156 wxPyEndAllowThreads(__tstate);
47157 if (PyErr_Occurred()) SWIG_fail;
47158 }
47159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47160 return resultobj;
47161 fail:
47162 return NULL;
47163 }
47164
47165
47166 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47167 PyObject *resultobj = 0;
47168 wxSizer *arg1 = (wxSizer *) 0 ;
47169 int arg2 ;
47170 PyObject *arg3 = (PyObject *) 0 ;
47171 int arg4 = (int) 0 ;
47172 int arg5 = (int) 0 ;
47173 int arg6 = (int) 0 ;
47174 PyObject *arg7 = (PyObject *) NULL ;
47175 wxSizerItem *result = 0 ;
47176 void *argp1 = 0 ;
47177 int res1 = 0 ;
47178 int val2 ;
47179 int ecode2 = 0 ;
47180 int val4 ;
47181 int ecode4 = 0 ;
47182 int val5 ;
47183 int ecode5 = 0 ;
47184 int val6 ;
47185 int ecode6 = 0 ;
47186 PyObject * obj0 = 0 ;
47187 PyObject * obj1 = 0 ;
47188 PyObject * obj2 = 0 ;
47189 PyObject * obj3 = 0 ;
47190 PyObject * obj4 = 0 ;
47191 PyObject * obj5 = 0 ;
47192 PyObject * obj6 = 0 ;
47193 char * kwnames[] = {
47194 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47195 };
47196
47197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47199 if (!SWIG_IsOK(res1)) {
47200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47201 }
47202 arg1 = reinterpret_cast< wxSizer * >(argp1);
47203 ecode2 = SWIG_AsVal_int(obj1, &val2);
47204 if (!SWIG_IsOK(ecode2)) {
47205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47206 }
47207 arg2 = static_cast< int >(val2);
47208 arg3 = obj2;
47209 if (obj3) {
47210 ecode4 = SWIG_AsVal_int(obj3, &val4);
47211 if (!SWIG_IsOK(ecode4)) {
47212 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47213 }
47214 arg4 = static_cast< int >(val4);
47215 }
47216 if (obj4) {
47217 ecode5 = SWIG_AsVal_int(obj4, &val5);
47218 if (!SWIG_IsOK(ecode5)) {
47219 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47220 }
47221 arg5 = static_cast< int >(val5);
47222 }
47223 if (obj5) {
47224 ecode6 = SWIG_AsVal_int(obj5, &val6);
47225 if (!SWIG_IsOK(ecode6)) {
47226 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47227 }
47228 arg6 = static_cast< int >(val6);
47229 }
47230 if (obj6) {
47231 arg7 = obj6;
47232 }
47233 {
47234 PyThreadState* __tstate = wxPyBeginAllowThreads();
47235 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47236 wxPyEndAllowThreads(__tstate);
47237 if (PyErr_Occurred()) SWIG_fail;
47238 }
47239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47240 return resultobj;
47241 fail:
47242 return NULL;
47243 }
47244
47245
47246 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47247 PyObject *resultobj = 0;
47248 wxSizer *arg1 = (wxSizer *) 0 ;
47249 PyObject *arg2 = (PyObject *) 0 ;
47250 int arg3 = (int) 0 ;
47251 int arg4 = (int) 0 ;
47252 int arg5 = (int) 0 ;
47253 PyObject *arg6 = (PyObject *) NULL ;
47254 wxSizerItem *result = 0 ;
47255 void *argp1 = 0 ;
47256 int res1 = 0 ;
47257 int val3 ;
47258 int ecode3 = 0 ;
47259 int val4 ;
47260 int ecode4 = 0 ;
47261 int val5 ;
47262 int ecode5 = 0 ;
47263 PyObject * obj0 = 0 ;
47264 PyObject * obj1 = 0 ;
47265 PyObject * obj2 = 0 ;
47266 PyObject * obj3 = 0 ;
47267 PyObject * obj4 = 0 ;
47268 PyObject * obj5 = 0 ;
47269 char * kwnames[] = {
47270 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47271 };
47272
47273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47275 if (!SWIG_IsOK(res1)) {
47276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47277 }
47278 arg1 = reinterpret_cast< wxSizer * >(argp1);
47279 arg2 = obj1;
47280 if (obj2) {
47281 ecode3 = SWIG_AsVal_int(obj2, &val3);
47282 if (!SWIG_IsOK(ecode3)) {
47283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47284 }
47285 arg3 = static_cast< int >(val3);
47286 }
47287 if (obj3) {
47288 ecode4 = SWIG_AsVal_int(obj3, &val4);
47289 if (!SWIG_IsOK(ecode4)) {
47290 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47291 }
47292 arg4 = static_cast< int >(val4);
47293 }
47294 if (obj4) {
47295 ecode5 = SWIG_AsVal_int(obj4, &val5);
47296 if (!SWIG_IsOK(ecode5)) {
47297 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47298 }
47299 arg5 = static_cast< int >(val5);
47300 }
47301 if (obj5) {
47302 arg6 = obj5;
47303 }
47304 {
47305 PyThreadState* __tstate = wxPyBeginAllowThreads();
47306 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47307 wxPyEndAllowThreads(__tstate);
47308 if (PyErr_Occurred()) SWIG_fail;
47309 }
47310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47311 return resultobj;
47312 fail:
47313 return NULL;
47314 }
47315
47316
47317 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47318 PyObject *resultobj = 0;
47319 wxSizer *arg1 = (wxSizer *) 0 ;
47320 PyObject *arg2 = (PyObject *) 0 ;
47321 bool result;
47322 void *argp1 = 0 ;
47323 int res1 = 0 ;
47324 PyObject * obj0 = 0 ;
47325 PyObject * obj1 = 0 ;
47326 char * kwnames[] = {
47327 (char *) "self",(char *) "item", NULL
47328 };
47329
47330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47332 if (!SWIG_IsOK(res1)) {
47333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47334 }
47335 arg1 = reinterpret_cast< wxSizer * >(argp1);
47336 arg2 = obj1;
47337 {
47338 PyThreadState* __tstate = wxPyBeginAllowThreads();
47339 result = (bool)wxSizer_Remove(arg1,arg2);
47340 wxPyEndAllowThreads(__tstate);
47341 if (PyErr_Occurred()) SWIG_fail;
47342 }
47343 {
47344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47345 }
47346 return resultobj;
47347 fail:
47348 return NULL;
47349 }
47350
47351
47352 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47353 PyObject *resultobj = 0;
47354 wxSizer *arg1 = (wxSizer *) 0 ;
47355 PyObject *arg2 = (PyObject *) 0 ;
47356 bool result;
47357 void *argp1 = 0 ;
47358 int res1 = 0 ;
47359 PyObject * obj0 = 0 ;
47360 PyObject * obj1 = 0 ;
47361 char * kwnames[] = {
47362 (char *) "self",(char *) "item", NULL
47363 };
47364
47365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47367 if (!SWIG_IsOK(res1)) {
47368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47369 }
47370 arg1 = reinterpret_cast< wxSizer * >(argp1);
47371 arg2 = obj1;
47372 {
47373 PyThreadState* __tstate = wxPyBeginAllowThreads();
47374 result = (bool)wxSizer_Detach(arg1,arg2);
47375 wxPyEndAllowThreads(__tstate);
47376 if (PyErr_Occurred()) SWIG_fail;
47377 }
47378 {
47379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47380 }
47381 return resultobj;
47382 fail:
47383 return NULL;
47384 }
47385
47386
47387 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47388 PyObject *resultobj = 0;
47389 wxSizer *arg1 = (wxSizer *) 0 ;
47390 PyObject *arg2 = (PyObject *) 0 ;
47391 wxSizerItem *result = 0 ;
47392 void *argp1 = 0 ;
47393 int res1 = 0 ;
47394 PyObject * obj0 = 0 ;
47395 PyObject * obj1 = 0 ;
47396 char * kwnames[] = {
47397 (char *) "self",(char *) "item", NULL
47398 };
47399
47400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47402 if (!SWIG_IsOK(res1)) {
47403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47404 }
47405 arg1 = reinterpret_cast< wxSizer * >(argp1);
47406 arg2 = obj1;
47407 {
47408 PyThreadState* __tstate = wxPyBeginAllowThreads();
47409 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47410 wxPyEndAllowThreads(__tstate);
47411 if (PyErr_Occurred()) SWIG_fail;
47412 }
47413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47414 return resultobj;
47415 fail:
47416 return NULL;
47417 }
47418
47419
47420 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47421 PyObject *resultobj = 0;
47422 wxSizer *arg1 = (wxSizer *) 0 ;
47423 PyObject *arg2 = (PyObject *) 0 ;
47424 wxSize *arg3 = 0 ;
47425 void *argp1 = 0 ;
47426 int res1 = 0 ;
47427 wxSize temp3 ;
47428 PyObject * obj0 = 0 ;
47429 PyObject * obj1 = 0 ;
47430 PyObject * obj2 = 0 ;
47431 char * kwnames[] = {
47432 (char *) "self",(char *) "item",(char *) "size", NULL
47433 };
47434
47435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47437 if (!SWIG_IsOK(res1)) {
47438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47439 }
47440 arg1 = reinterpret_cast< wxSizer * >(argp1);
47441 arg2 = obj1;
47442 {
47443 arg3 = &temp3;
47444 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47445 }
47446 {
47447 PyThreadState* __tstate = wxPyBeginAllowThreads();
47448 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47449 wxPyEndAllowThreads(__tstate);
47450 if (PyErr_Occurred()) SWIG_fail;
47451 }
47452 resultobj = SWIG_Py_Void();
47453 return resultobj;
47454 fail:
47455 return NULL;
47456 }
47457
47458
47459 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47460 PyObject *resultobj = 0;
47461 wxSizer *arg1 = (wxSizer *) 0 ;
47462 wxWindow *arg2 = (wxWindow *) 0 ;
47463 wxWindow *arg3 = (wxWindow *) 0 ;
47464 bool arg4 = (bool) false ;
47465 bool result;
47466 void *argp1 = 0 ;
47467 int res1 = 0 ;
47468 void *argp2 = 0 ;
47469 int res2 = 0 ;
47470 void *argp3 = 0 ;
47471 int res3 = 0 ;
47472 bool val4 ;
47473 int ecode4 = 0 ;
47474 PyObject * obj0 = 0 ;
47475 PyObject * obj1 = 0 ;
47476 PyObject * obj2 = 0 ;
47477 PyObject * obj3 = 0 ;
47478 char * kwnames[] = {
47479 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47480 };
47481
47482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47484 if (!SWIG_IsOK(res1)) {
47485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47486 }
47487 arg1 = reinterpret_cast< wxSizer * >(argp1);
47488 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47489 if (!SWIG_IsOK(res2)) {
47490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47491 }
47492 arg2 = reinterpret_cast< wxWindow * >(argp2);
47493 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47494 if (!SWIG_IsOK(res3)) {
47495 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47496 }
47497 arg3 = reinterpret_cast< wxWindow * >(argp3);
47498 if (obj3) {
47499 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47500 if (!SWIG_IsOK(ecode4)) {
47501 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47502 }
47503 arg4 = static_cast< bool >(val4);
47504 }
47505 {
47506 PyThreadState* __tstate = wxPyBeginAllowThreads();
47507 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47508 wxPyEndAllowThreads(__tstate);
47509 if (PyErr_Occurred()) SWIG_fail;
47510 }
47511 {
47512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47513 }
47514 return resultobj;
47515 fail:
47516 return NULL;
47517 }
47518
47519
47520 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47521 PyObject *resultobj = 0;
47522 wxSizer *arg1 = (wxSizer *) 0 ;
47523 wxSizer *arg2 = (wxSizer *) 0 ;
47524 wxSizer *arg3 = (wxSizer *) 0 ;
47525 bool arg4 = (bool) false ;
47526 bool result;
47527 void *argp1 = 0 ;
47528 int res1 = 0 ;
47529 void *argp2 = 0 ;
47530 int res2 = 0 ;
47531 void *argp3 = 0 ;
47532 int res3 = 0 ;
47533 bool val4 ;
47534 int ecode4 = 0 ;
47535 PyObject * obj0 = 0 ;
47536 PyObject * obj1 = 0 ;
47537 PyObject * obj2 = 0 ;
47538 PyObject * obj3 = 0 ;
47539 char * kwnames[] = {
47540 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47541 };
47542
47543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47545 if (!SWIG_IsOK(res1)) {
47546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47547 }
47548 arg1 = reinterpret_cast< wxSizer * >(argp1);
47549 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47550 if (!SWIG_IsOK(res2)) {
47551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47552 }
47553 arg2 = reinterpret_cast< wxSizer * >(argp2);
47554 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47555 if (!SWIG_IsOK(res3)) {
47556 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47557 }
47558 arg3 = reinterpret_cast< wxSizer * >(argp3);
47559 if (obj3) {
47560 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47561 if (!SWIG_IsOK(ecode4)) {
47562 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47563 }
47564 arg4 = static_cast< bool >(val4);
47565 }
47566 {
47567 PyThreadState* __tstate = wxPyBeginAllowThreads();
47568 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47569 wxPyEndAllowThreads(__tstate);
47570 if (PyErr_Occurred()) SWIG_fail;
47571 }
47572 {
47573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47574 }
47575 return resultobj;
47576 fail:
47577 return NULL;
47578 }
47579
47580
47581 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47582 PyObject *resultobj = 0;
47583 wxSizer *arg1 = (wxSizer *) 0 ;
47584 size_t arg2 ;
47585 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47586 bool result;
47587 void *argp1 = 0 ;
47588 int res1 = 0 ;
47589 size_t val2 ;
47590 int ecode2 = 0 ;
47591 void *argp3 = 0 ;
47592 int res3 = 0 ;
47593 PyObject * obj0 = 0 ;
47594 PyObject * obj1 = 0 ;
47595 PyObject * obj2 = 0 ;
47596 char * kwnames[] = {
47597 (char *) "self",(char *) "index",(char *) "newitem", NULL
47598 };
47599
47600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47602 if (!SWIG_IsOK(res1)) {
47603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47604 }
47605 arg1 = reinterpret_cast< wxSizer * >(argp1);
47606 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47607 if (!SWIG_IsOK(ecode2)) {
47608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
47609 }
47610 arg2 = static_cast< size_t >(val2);
47611 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47612 if (!SWIG_IsOK(res3)) {
47613 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47614 }
47615 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
47616 {
47617 PyThreadState* __tstate = wxPyBeginAllowThreads();
47618 result = (bool)(arg1)->Replace(arg2,arg3);
47619 wxPyEndAllowThreads(__tstate);
47620 if (PyErr_Occurred()) SWIG_fail;
47621 }
47622 {
47623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47624 }
47625 return resultobj;
47626 fail:
47627 return NULL;
47628 }
47629
47630
47631 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47632 PyObject *resultobj = 0;
47633 wxSizer *arg1 = (wxSizer *) 0 ;
47634 wxWindow *arg2 = (wxWindow *) 0 ;
47635 void *argp1 = 0 ;
47636 int res1 = 0 ;
47637 void *argp2 = 0 ;
47638 int res2 = 0 ;
47639 PyObject * obj0 = 0 ;
47640 PyObject * obj1 = 0 ;
47641 char * kwnames[] = {
47642 (char *) "self",(char *) "window", NULL
47643 };
47644
47645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47647 if (!SWIG_IsOK(res1)) {
47648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
47649 }
47650 arg1 = reinterpret_cast< wxSizer * >(argp1);
47651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47652 if (!SWIG_IsOK(res2)) {
47653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47654 }
47655 arg2 = reinterpret_cast< wxWindow * >(argp2);
47656 {
47657 PyThreadState* __tstate = wxPyBeginAllowThreads();
47658 (arg1)->SetContainingWindow(arg2);
47659 wxPyEndAllowThreads(__tstate);
47660 if (PyErr_Occurred()) SWIG_fail;
47661 }
47662 resultobj = SWIG_Py_Void();
47663 return resultobj;
47664 fail:
47665 return NULL;
47666 }
47667
47668
47669 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47670 PyObject *resultobj = 0;
47671 wxSizer *arg1 = (wxSizer *) 0 ;
47672 wxWindow *result = 0 ;
47673 void *argp1 = 0 ;
47674 int res1 = 0 ;
47675 PyObject *swig_obj[1] ;
47676
47677 if (!args) SWIG_fail;
47678 swig_obj[0] = args;
47679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47680 if (!SWIG_IsOK(res1)) {
47681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
47682 }
47683 arg1 = reinterpret_cast< wxSizer * >(argp1);
47684 {
47685 PyThreadState* __tstate = wxPyBeginAllowThreads();
47686 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
47687 wxPyEndAllowThreads(__tstate);
47688 if (PyErr_Occurred()) SWIG_fail;
47689 }
47690 {
47691 resultobj = wxPyMake_wxObject(result, 0);
47692 }
47693 return resultobj;
47694 fail:
47695 return NULL;
47696 }
47697
47698
47699 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47700 PyObject *resultobj = 0;
47701 wxSizer *arg1 = (wxSizer *) 0 ;
47702 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47703 wxSizerItem *result = 0 ;
47704 void *argp1 = 0 ;
47705 int res1 = 0 ;
47706 int res2 = 0 ;
47707 PyObject * obj0 = 0 ;
47708 PyObject * obj1 = 0 ;
47709 char * kwnames[] = {
47710 (char *) "self",(char *) "item", NULL
47711 };
47712
47713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47715 if (!SWIG_IsOK(res1)) {
47716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47717 }
47718 arg1 = reinterpret_cast< wxSizer * >(argp1);
47719 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47720 if (!SWIG_IsOK(res2)) {
47721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47722 }
47723 {
47724 PyThreadState* __tstate = wxPyBeginAllowThreads();
47725 result = (wxSizerItem *)(arg1)->Add(arg2);
47726 wxPyEndAllowThreads(__tstate);
47727 if (PyErr_Occurred()) SWIG_fail;
47728 }
47729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47730 return resultobj;
47731 fail:
47732 return NULL;
47733 }
47734
47735
47736 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47737 PyObject *resultobj = 0;
47738 wxSizer *arg1 = (wxSizer *) 0 ;
47739 size_t arg2 ;
47740 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47741 wxSizerItem *result = 0 ;
47742 void *argp1 = 0 ;
47743 int res1 = 0 ;
47744 size_t val2 ;
47745 int ecode2 = 0 ;
47746 int res3 = 0 ;
47747 PyObject * obj0 = 0 ;
47748 PyObject * obj1 = 0 ;
47749 PyObject * obj2 = 0 ;
47750 char * kwnames[] = {
47751 (char *) "self",(char *) "index",(char *) "item", NULL
47752 };
47753
47754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47756 if (!SWIG_IsOK(res1)) {
47757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47758 }
47759 arg1 = reinterpret_cast< wxSizer * >(argp1);
47760 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47761 if (!SWIG_IsOK(ecode2)) {
47762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47763 }
47764 arg2 = static_cast< size_t >(val2);
47765 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47766 if (!SWIG_IsOK(res3)) {
47767 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47768 }
47769 {
47770 PyThreadState* __tstate = wxPyBeginAllowThreads();
47771 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47772 wxPyEndAllowThreads(__tstate);
47773 if (PyErr_Occurred()) SWIG_fail;
47774 }
47775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47776 return resultobj;
47777 fail:
47778 return NULL;
47779 }
47780
47781
47782 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47783 PyObject *resultobj = 0;
47784 wxSizer *arg1 = (wxSizer *) 0 ;
47785 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47786 wxSizerItem *result = 0 ;
47787 void *argp1 = 0 ;
47788 int res1 = 0 ;
47789 int res2 = 0 ;
47790 PyObject * obj0 = 0 ;
47791 PyObject * obj1 = 0 ;
47792 char * kwnames[] = {
47793 (char *) "self",(char *) "item", NULL
47794 };
47795
47796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47798 if (!SWIG_IsOK(res1)) {
47799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47800 }
47801 arg1 = reinterpret_cast< wxSizer * >(argp1);
47802 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47803 if (!SWIG_IsOK(res2)) {
47804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47805 }
47806 {
47807 PyThreadState* __tstate = wxPyBeginAllowThreads();
47808 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47809 wxPyEndAllowThreads(__tstate);
47810 if (PyErr_Occurred()) SWIG_fail;
47811 }
47812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47813 return resultobj;
47814 fail:
47815 return NULL;
47816 }
47817
47818
47819 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47820 PyObject *resultobj = 0;
47821 wxSizer *arg1 = (wxSizer *) 0 ;
47822 int arg2 ;
47823 int arg3 ;
47824 int arg4 ;
47825 int arg5 ;
47826 void *argp1 = 0 ;
47827 int res1 = 0 ;
47828 int val2 ;
47829 int ecode2 = 0 ;
47830 int val3 ;
47831 int ecode3 = 0 ;
47832 int val4 ;
47833 int ecode4 = 0 ;
47834 int val5 ;
47835 int ecode5 = 0 ;
47836 PyObject * obj0 = 0 ;
47837 PyObject * obj1 = 0 ;
47838 PyObject * obj2 = 0 ;
47839 PyObject * obj3 = 0 ;
47840 PyObject * obj4 = 0 ;
47841 char * kwnames[] = {
47842 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47843 };
47844
47845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47847 if (!SWIG_IsOK(res1)) {
47848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47849 }
47850 arg1 = reinterpret_cast< wxSizer * >(argp1);
47851 ecode2 = SWIG_AsVal_int(obj1, &val2);
47852 if (!SWIG_IsOK(ecode2)) {
47853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47854 }
47855 arg2 = static_cast< int >(val2);
47856 ecode3 = SWIG_AsVal_int(obj2, &val3);
47857 if (!SWIG_IsOK(ecode3)) {
47858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47859 }
47860 arg3 = static_cast< int >(val3);
47861 ecode4 = SWIG_AsVal_int(obj3, &val4);
47862 if (!SWIG_IsOK(ecode4)) {
47863 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47864 }
47865 arg4 = static_cast< int >(val4);
47866 ecode5 = SWIG_AsVal_int(obj4, &val5);
47867 if (!SWIG_IsOK(ecode5)) {
47868 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47869 }
47870 arg5 = static_cast< int >(val5);
47871 {
47872 PyThreadState* __tstate = wxPyBeginAllowThreads();
47873 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47874 wxPyEndAllowThreads(__tstate);
47875 if (PyErr_Occurred()) SWIG_fail;
47876 }
47877 resultobj = SWIG_Py_Void();
47878 return resultobj;
47879 fail:
47880 return NULL;
47881 }
47882
47883
47884 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47885 PyObject *resultobj = 0;
47886 wxSizer *arg1 = (wxSizer *) 0 ;
47887 wxSize *arg2 = 0 ;
47888 void *argp1 = 0 ;
47889 int res1 = 0 ;
47890 wxSize temp2 ;
47891 PyObject * obj0 = 0 ;
47892 PyObject * obj1 = 0 ;
47893 char * kwnames[] = {
47894 (char *) "self",(char *) "size", NULL
47895 };
47896
47897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47899 if (!SWIG_IsOK(res1)) {
47900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47901 }
47902 arg1 = reinterpret_cast< wxSizer * >(argp1);
47903 {
47904 arg2 = &temp2;
47905 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47906 }
47907 {
47908 PyThreadState* __tstate = wxPyBeginAllowThreads();
47909 (arg1)->SetMinSize((wxSize const &)*arg2);
47910 wxPyEndAllowThreads(__tstate);
47911 if (PyErr_Occurred()) SWIG_fail;
47912 }
47913 resultobj = SWIG_Py_Void();
47914 return resultobj;
47915 fail:
47916 return NULL;
47917 }
47918
47919
47920 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47921 PyObject *resultobj = 0;
47922 wxSizer *arg1 = (wxSizer *) 0 ;
47923 wxSize result;
47924 void *argp1 = 0 ;
47925 int res1 = 0 ;
47926 PyObject *swig_obj[1] ;
47927
47928 if (!args) SWIG_fail;
47929 swig_obj[0] = args;
47930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47931 if (!SWIG_IsOK(res1)) {
47932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47933 }
47934 arg1 = reinterpret_cast< wxSizer * >(argp1);
47935 {
47936 PyThreadState* __tstate = wxPyBeginAllowThreads();
47937 result = (arg1)->GetSize();
47938 wxPyEndAllowThreads(__tstate);
47939 if (PyErr_Occurred()) SWIG_fail;
47940 }
47941 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47942 return resultobj;
47943 fail:
47944 return NULL;
47945 }
47946
47947
47948 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47949 PyObject *resultobj = 0;
47950 wxSizer *arg1 = (wxSizer *) 0 ;
47951 wxPoint result;
47952 void *argp1 = 0 ;
47953 int res1 = 0 ;
47954 PyObject *swig_obj[1] ;
47955
47956 if (!args) SWIG_fail;
47957 swig_obj[0] = args;
47958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47959 if (!SWIG_IsOK(res1)) {
47960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47961 }
47962 arg1 = reinterpret_cast< wxSizer * >(argp1);
47963 {
47964 PyThreadState* __tstate = wxPyBeginAllowThreads();
47965 result = (arg1)->GetPosition();
47966 wxPyEndAllowThreads(__tstate);
47967 if (PyErr_Occurred()) SWIG_fail;
47968 }
47969 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47970 return resultobj;
47971 fail:
47972 return NULL;
47973 }
47974
47975
47976 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47977 PyObject *resultobj = 0;
47978 wxSizer *arg1 = (wxSizer *) 0 ;
47979 wxSize result;
47980 void *argp1 = 0 ;
47981 int res1 = 0 ;
47982 PyObject *swig_obj[1] ;
47983
47984 if (!args) SWIG_fail;
47985 swig_obj[0] = args;
47986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47987 if (!SWIG_IsOK(res1)) {
47988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47989 }
47990 arg1 = reinterpret_cast< wxSizer * >(argp1);
47991 {
47992 PyThreadState* __tstate = wxPyBeginAllowThreads();
47993 result = (arg1)->GetMinSize();
47994 wxPyEndAllowThreads(__tstate);
47995 if (PyErr_Occurred()) SWIG_fail;
47996 }
47997 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47998 return resultobj;
47999 fail:
48000 return NULL;
48001 }
48002
48003
48004 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48005 PyObject *resultobj = 0;
48006 wxSizer *arg1 = (wxSizer *) 0 ;
48007 void *argp1 = 0 ;
48008 int res1 = 0 ;
48009 PyObject *swig_obj[1] ;
48010
48011 if (!args) SWIG_fail;
48012 swig_obj[0] = args;
48013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48014 if (!SWIG_IsOK(res1)) {
48015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48016 }
48017 arg1 = reinterpret_cast< wxSizer * >(argp1);
48018 {
48019 PyThreadState* __tstate = wxPyBeginAllowThreads();
48020 (arg1)->RecalcSizes();
48021 wxPyEndAllowThreads(__tstate);
48022 if (PyErr_Occurred()) SWIG_fail;
48023 }
48024 resultobj = SWIG_Py_Void();
48025 return resultobj;
48026 fail:
48027 return NULL;
48028 }
48029
48030
48031 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48032 PyObject *resultobj = 0;
48033 wxSizer *arg1 = (wxSizer *) 0 ;
48034 wxSize result;
48035 void *argp1 = 0 ;
48036 int res1 = 0 ;
48037 PyObject *swig_obj[1] ;
48038
48039 if (!args) SWIG_fail;
48040 swig_obj[0] = args;
48041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48042 if (!SWIG_IsOK(res1)) {
48043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48044 }
48045 arg1 = reinterpret_cast< wxSizer * >(argp1);
48046 {
48047 PyThreadState* __tstate = wxPyBeginAllowThreads();
48048 result = (arg1)->CalcMin();
48049 wxPyEndAllowThreads(__tstate);
48050 if (PyErr_Occurred()) SWIG_fail;
48051 }
48052 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48053 return resultobj;
48054 fail:
48055 return NULL;
48056 }
48057
48058
48059 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48060 PyObject *resultobj = 0;
48061 wxSizer *arg1 = (wxSizer *) 0 ;
48062 void *argp1 = 0 ;
48063 int res1 = 0 ;
48064 PyObject *swig_obj[1] ;
48065
48066 if (!args) SWIG_fail;
48067 swig_obj[0] = args;
48068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48069 if (!SWIG_IsOK(res1)) {
48070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48071 }
48072 arg1 = reinterpret_cast< wxSizer * >(argp1);
48073 {
48074 PyThreadState* __tstate = wxPyBeginAllowThreads();
48075 (arg1)->Layout();
48076 wxPyEndAllowThreads(__tstate);
48077 if (PyErr_Occurred()) SWIG_fail;
48078 }
48079 resultobj = SWIG_Py_Void();
48080 return resultobj;
48081 fail:
48082 return NULL;
48083 }
48084
48085
48086 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48087 PyObject *resultobj = 0;
48088 wxSizer *arg1 = (wxSizer *) 0 ;
48089 wxWindow *arg2 = (wxWindow *) 0 ;
48090 wxSize result;
48091 void *argp1 = 0 ;
48092 int res1 = 0 ;
48093 void *argp2 = 0 ;
48094 int res2 = 0 ;
48095 PyObject * obj0 = 0 ;
48096 PyObject * obj1 = 0 ;
48097 char * kwnames[] = {
48098 (char *) "self",(char *) "window", NULL
48099 };
48100
48101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48103 if (!SWIG_IsOK(res1)) {
48104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48105 }
48106 arg1 = reinterpret_cast< wxSizer * >(argp1);
48107 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48108 if (!SWIG_IsOK(res2)) {
48109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48110 }
48111 arg2 = reinterpret_cast< wxWindow * >(argp2);
48112 {
48113 PyThreadState* __tstate = wxPyBeginAllowThreads();
48114 result = (arg1)->Fit(arg2);
48115 wxPyEndAllowThreads(__tstate);
48116 if (PyErr_Occurred()) SWIG_fail;
48117 }
48118 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48119 return resultobj;
48120 fail:
48121 return NULL;
48122 }
48123
48124
48125 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48126 PyObject *resultobj = 0;
48127 wxSizer *arg1 = (wxSizer *) 0 ;
48128 wxWindow *arg2 = (wxWindow *) 0 ;
48129 void *argp1 = 0 ;
48130 int res1 = 0 ;
48131 void *argp2 = 0 ;
48132 int res2 = 0 ;
48133 PyObject * obj0 = 0 ;
48134 PyObject * obj1 = 0 ;
48135 char * kwnames[] = {
48136 (char *) "self",(char *) "window", NULL
48137 };
48138
48139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48141 if (!SWIG_IsOK(res1)) {
48142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48143 }
48144 arg1 = reinterpret_cast< wxSizer * >(argp1);
48145 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48146 if (!SWIG_IsOK(res2)) {
48147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48148 }
48149 arg2 = reinterpret_cast< wxWindow * >(argp2);
48150 {
48151 PyThreadState* __tstate = wxPyBeginAllowThreads();
48152 (arg1)->FitInside(arg2);
48153 wxPyEndAllowThreads(__tstate);
48154 if (PyErr_Occurred()) SWIG_fail;
48155 }
48156 resultobj = SWIG_Py_Void();
48157 return resultobj;
48158 fail:
48159 return NULL;
48160 }
48161
48162
48163 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48164 PyObject *resultobj = 0;
48165 wxSizer *arg1 = (wxSizer *) 0 ;
48166 wxWindow *arg2 = (wxWindow *) 0 ;
48167 void *argp1 = 0 ;
48168 int res1 = 0 ;
48169 void *argp2 = 0 ;
48170 int res2 = 0 ;
48171 PyObject * obj0 = 0 ;
48172 PyObject * obj1 = 0 ;
48173 char * kwnames[] = {
48174 (char *) "self",(char *) "window", NULL
48175 };
48176
48177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48179 if (!SWIG_IsOK(res1)) {
48180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48181 }
48182 arg1 = reinterpret_cast< wxSizer * >(argp1);
48183 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48184 if (!SWIG_IsOK(res2)) {
48185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48186 }
48187 arg2 = reinterpret_cast< wxWindow * >(argp2);
48188 {
48189 PyThreadState* __tstate = wxPyBeginAllowThreads();
48190 (arg1)->SetSizeHints(arg2);
48191 wxPyEndAllowThreads(__tstate);
48192 if (PyErr_Occurred()) SWIG_fail;
48193 }
48194 resultobj = SWIG_Py_Void();
48195 return resultobj;
48196 fail:
48197 return NULL;
48198 }
48199
48200
48201 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48202 PyObject *resultobj = 0;
48203 wxSizer *arg1 = (wxSizer *) 0 ;
48204 wxWindow *arg2 = (wxWindow *) 0 ;
48205 void *argp1 = 0 ;
48206 int res1 = 0 ;
48207 void *argp2 = 0 ;
48208 int res2 = 0 ;
48209 PyObject * obj0 = 0 ;
48210 PyObject * obj1 = 0 ;
48211 char * kwnames[] = {
48212 (char *) "self",(char *) "window", NULL
48213 };
48214
48215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48217 if (!SWIG_IsOK(res1)) {
48218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48219 }
48220 arg1 = reinterpret_cast< wxSizer * >(argp1);
48221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48222 if (!SWIG_IsOK(res2)) {
48223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48224 }
48225 arg2 = reinterpret_cast< wxWindow * >(argp2);
48226 {
48227 PyThreadState* __tstate = wxPyBeginAllowThreads();
48228 (arg1)->SetVirtualSizeHints(arg2);
48229 wxPyEndAllowThreads(__tstate);
48230 if (PyErr_Occurred()) SWIG_fail;
48231 }
48232 resultobj = SWIG_Py_Void();
48233 return resultobj;
48234 fail:
48235 return NULL;
48236 }
48237
48238
48239 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48240 PyObject *resultobj = 0;
48241 wxSizer *arg1 = (wxSizer *) 0 ;
48242 bool arg2 = (bool) false ;
48243 void *argp1 = 0 ;
48244 int res1 = 0 ;
48245 bool val2 ;
48246 int ecode2 = 0 ;
48247 PyObject * obj0 = 0 ;
48248 PyObject * obj1 = 0 ;
48249 char * kwnames[] = {
48250 (char *) "self",(char *) "deleteWindows", NULL
48251 };
48252
48253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48255 if (!SWIG_IsOK(res1)) {
48256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48257 }
48258 arg1 = reinterpret_cast< wxSizer * >(argp1);
48259 if (obj1) {
48260 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48261 if (!SWIG_IsOK(ecode2)) {
48262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48263 }
48264 arg2 = static_cast< bool >(val2);
48265 }
48266 {
48267 PyThreadState* __tstate = wxPyBeginAllowThreads();
48268 (arg1)->Clear(arg2);
48269 wxPyEndAllowThreads(__tstate);
48270 if (PyErr_Occurred()) SWIG_fail;
48271 }
48272 resultobj = SWIG_Py_Void();
48273 return resultobj;
48274 fail:
48275 return NULL;
48276 }
48277
48278
48279 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48280 PyObject *resultobj = 0;
48281 wxSizer *arg1 = (wxSizer *) 0 ;
48282 void *argp1 = 0 ;
48283 int res1 = 0 ;
48284 PyObject *swig_obj[1] ;
48285
48286 if (!args) SWIG_fail;
48287 swig_obj[0] = args;
48288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48289 if (!SWIG_IsOK(res1)) {
48290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48291 }
48292 arg1 = reinterpret_cast< wxSizer * >(argp1);
48293 {
48294 PyThreadState* __tstate = wxPyBeginAllowThreads();
48295 (arg1)->DeleteWindows();
48296 wxPyEndAllowThreads(__tstate);
48297 if (PyErr_Occurred()) SWIG_fail;
48298 }
48299 resultobj = SWIG_Py_Void();
48300 return resultobj;
48301 fail:
48302 return NULL;
48303 }
48304
48305
48306 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48307 PyObject *resultobj = 0;
48308 wxSizer *arg1 = (wxSizer *) 0 ;
48309 PyObject *result = 0 ;
48310 void *argp1 = 0 ;
48311 int res1 = 0 ;
48312 PyObject *swig_obj[1] ;
48313
48314 if (!args) SWIG_fail;
48315 swig_obj[0] = args;
48316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48317 if (!SWIG_IsOK(res1)) {
48318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48319 }
48320 arg1 = reinterpret_cast< wxSizer * >(argp1);
48321 {
48322 PyThreadState* __tstate = wxPyBeginAllowThreads();
48323 result = (PyObject *)wxSizer_GetChildren(arg1);
48324 wxPyEndAllowThreads(__tstate);
48325 if (PyErr_Occurred()) SWIG_fail;
48326 }
48327 resultobj = result;
48328 return resultobj;
48329 fail:
48330 return NULL;
48331 }
48332
48333
48334 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48335 PyObject *resultobj = 0;
48336 wxSizer *arg1 = (wxSizer *) 0 ;
48337 PyObject *arg2 = (PyObject *) 0 ;
48338 bool arg3 = (bool) true ;
48339 bool arg4 = (bool) false ;
48340 bool result;
48341 void *argp1 = 0 ;
48342 int res1 = 0 ;
48343 bool val3 ;
48344 int ecode3 = 0 ;
48345 bool val4 ;
48346 int ecode4 = 0 ;
48347 PyObject * obj0 = 0 ;
48348 PyObject * obj1 = 0 ;
48349 PyObject * obj2 = 0 ;
48350 PyObject * obj3 = 0 ;
48351 char * kwnames[] = {
48352 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48353 };
48354
48355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48357 if (!SWIG_IsOK(res1)) {
48358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48359 }
48360 arg1 = reinterpret_cast< wxSizer * >(argp1);
48361 arg2 = obj1;
48362 if (obj2) {
48363 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48364 if (!SWIG_IsOK(ecode3)) {
48365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48366 }
48367 arg3 = static_cast< bool >(val3);
48368 }
48369 if (obj3) {
48370 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48371 if (!SWIG_IsOK(ecode4)) {
48372 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48373 }
48374 arg4 = static_cast< bool >(val4);
48375 }
48376 {
48377 PyThreadState* __tstate = wxPyBeginAllowThreads();
48378 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48379 wxPyEndAllowThreads(__tstate);
48380 if (PyErr_Occurred()) SWIG_fail;
48381 }
48382 {
48383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48384 }
48385 return resultobj;
48386 fail:
48387 return NULL;
48388 }
48389
48390
48391 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48392 PyObject *resultobj = 0;
48393 wxSizer *arg1 = (wxSizer *) 0 ;
48394 PyObject *arg2 = (PyObject *) 0 ;
48395 bool result;
48396 void *argp1 = 0 ;
48397 int res1 = 0 ;
48398 PyObject * obj0 = 0 ;
48399 PyObject * obj1 = 0 ;
48400 char * kwnames[] = {
48401 (char *) "self",(char *) "item", NULL
48402 };
48403
48404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48406 if (!SWIG_IsOK(res1)) {
48407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48408 }
48409 arg1 = reinterpret_cast< wxSizer * >(argp1);
48410 arg2 = obj1;
48411 {
48412 PyThreadState* __tstate = wxPyBeginAllowThreads();
48413 result = (bool)wxSizer_IsShown(arg1,arg2);
48414 wxPyEndAllowThreads(__tstate);
48415 if (PyErr_Occurred()) SWIG_fail;
48416 }
48417 {
48418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48419 }
48420 return resultobj;
48421 fail:
48422 return NULL;
48423 }
48424
48425
48426 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48427 PyObject *resultobj = 0;
48428 wxSizer *arg1 = (wxSizer *) 0 ;
48429 bool arg2 ;
48430 void *argp1 = 0 ;
48431 int res1 = 0 ;
48432 bool val2 ;
48433 int ecode2 = 0 ;
48434 PyObject * obj0 = 0 ;
48435 PyObject * obj1 = 0 ;
48436 char * kwnames[] = {
48437 (char *) "self",(char *) "show", NULL
48438 };
48439
48440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48442 if (!SWIG_IsOK(res1)) {
48443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48444 }
48445 arg1 = reinterpret_cast< wxSizer * >(argp1);
48446 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48447 if (!SWIG_IsOK(ecode2)) {
48448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48449 }
48450 arg2 = static_cast< bool >(val2);
48451 {
48452 PyThreadState* __tstate = wxPyBeginAllowThreads();
48453 (arg1)->ShowItems(arg2);
48454 wxPyEndAllowThreads(__tstate);
48455 if (PyErr_Occurred()) SWIG_fail;
48456 }
48457 resultobj = SWIG_Py_Void();
48458 return resultobj;
48459 fail:
48460 return NULL;
48461 }
48462
48463
48464 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48465 PyObject *obj;
48466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48467 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48468 return SWIG_Py_Void();
48469 }
48470
48471 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48472 PyObject *resultobj = 0;
48473 wxPySizer *result = 0 ;
48474
48475 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48476 {
48477 PyThreadState* __tstate = wxPyBeginAllowThreads();
48478 result = (wxPySizer *)new wxPySizer();
48479 wxPyEndAllowThreads(__tstate);
48480 if (PyErr_Occurred()) SWIG_fail;
48481 }
48482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48483 return resultobj;
48484 fail:
48485 return NULL;
48486 }
48487
48488
48489 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48490 PyObject *resultobj = 0;
48491 wxPySizer *arg1 = (wxPySizer *) 0 ;
48492 PyObject *arg2 = (PyObject *) 0 ;
48493 PyObject *arg3 = (PyObject *) 0 ;
48494 void *argp1 = 0 ;
48495 int res1 = 0 ;
48496 PyObject * obj0 = 0 ;
48497 PyObject * obj1 = 0 ;
48498 PyObject * obj2 = 0 ;
48499 char * kwnames[] = {
48500 (char *) "self",(char *) "self",(char *) "_class", NULL
48501 };
48502
48503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48505 if (!SWIG_IsOK(res1)) {
48506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48507 }
48508 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48509 arg2 = obj1;
48510 arg3 = obj2;
48511 {
48512 PyThreadState* __tstate = wxPyBeginAllowThreads();
48513 (arg1)->_setCallbackInfo(arg2,arg3);
48514 wxPyEndAllowThreads(__tstate);
48515 if (PyErr_Occurred()) SWIG_fail;
48516 }
48517 resultobj = SWIG_Py_Void();
48518 return resultobj;
48519 fail:
48520 return NULL;
48521 }
48522
48523
48524 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48525 PyObject *obj;
48526 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48527 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48528 return SWIG_Py_Void();
48529 }
48530
48531 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48532 return SWIG_Python_InitShadowInstance(args);
48533 }
48534
48535 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48536 PyObject *resultobj = 0;
48537 int arg1 = (int) wxHORIZONTAL ;
48538 wxBoxSizer *result = 0 ;
48539 int val1 ;
48540 int ecode1 = 0 ;
48541 PyObject * obj0 = 0 ;
48542 char * kwnames[] = {
48543 (char *) "orient", NULL
48544 };
48545
48546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48547 if (obj0) {
48548 ecode1 = SWIG_AsVal_int(obj0, &val1);
48549 if (!SWIG_IsOK(ecode1)) {
48550 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48551 }
48552 arg1 = static_cast< int >(val1);
48553 }
48554 {
48555 PyThreadState* __tstate = wxPyBeginAllowThreads();
48556 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48557 wxPyEndAllowThreads(__tstate);
48558 if (PyErr_Occurred()) SWIG_fail;
48559 }
48560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48561 return resultobj;
48562 fail:
48563 return NULL;
48564 }
48565
48566
48567 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48568 PyObject *resultobj = 0;
48569 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48570 int result;
48571 void *argp1 = 0 ;
48572 int res1 = 0 ;
48573 PyObject *swig_obj[1] ;
48574
48575 if (!args) SWIG_fail;
48576 swig_obj[0] = args;
48577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48578 if (!SWIG_IsOK(res1)) {
48579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48580 }
48581 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48582 {
48583 PyThreadState* __tstate = wxPyBeginAllowThreads();
48584 result = (int)(arg1)->GetOrientation();
48585 wxPyEndAllowThreads(__tstate);
48586 if (PyErr_Occurred()) SWIG_fail;
48587 }
48588 resultobj = SWIG_From_int(static_cast< int >(result));
48589 return resultobj;
48590 fail:
48591 return NULL;
48592 }
48593
48594
48595 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48596 PyObject *resultobj = 0;
48597 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48598 int arg2 ;
48599 void *argp1 = 0 ;
48600 int res1 = 0 ;
48601 int val2 ;
48602 int ecode2 = 0 ;
48603 PyObject * obj0 = 0 ;
48604 PyObject * obj1 = 0 ;
48605 char * kwnames[] = {
48606 (char *) "self",(char *) "orient", NULL
48607 };
48608
48609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
48610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48611 if (!SWIG_IsOK(res1)) {
48612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48613 }
48614 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48615 ecode2 = SWIG_AsVal_int(obj1, &val2);
48616 if (!SWIG_IsOK(ecode2)) {
48617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
48618 }
48619 arg2 = static_cast< int >(val2);
48620 {
48621 PyThreadState* __tstate = wxPyBeginAllowThreads();
48622 (arg1)->SetOrientation(arg2);
48623 wxPyEndAllowThreads(__tstate);
48624 if (PyErr_Occurred()) SWIG_fail;
48625 }
48626 resultobj = SWIG_Py_Void();
48627 return resultobj;
48628 fail:
48629 return NULL;
48630 }
48631
48632
48633 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48634 PyObject *obj;
48635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48636 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
48637 return SWIG_Py_Void();
48638 }
48639
48640 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48641 return SWIG_Python_InitShadowInstance(args);
48642 }
48643
48644 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48645 PyObject *resultobj = 0;
48646 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
48647 int arg2 = (int) wxHORIZONTAL ;
48648 wxStaticBoxSizer *result = 0 ;
48649 void *argp1 = 0 ;
48650 int res1 = 0 ;
48651 int val2 ;
48652 int ecode2 = 0 ;
48653 PyObject * obj0 = 0 ;
48654 PyObject * obj1 = 0 ;
48655 char * kwnames[] = {
48656 (char *) "box",(char *) "orient", NULL
48657 };
48658
48659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
48660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
48661 if (!SWIG_IsOK(res1)) {
48662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
48663 }
48664 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
48665 if (obj1) {
48666 ecode2 = SWIG_AsVal_int(obj1, &val2);
48667 if (!SWIG_IsOK(ecode2)) {
48668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48669 }
48670 arg2 = static_cast< int >(val2);
48671 }
48672 {
48673 PyThreadState* __tstate = wxPyBeginAllowThreads();
48674 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48675 wxPyEndAllowThreads(__tstate);
48676 if (PyErr_Occurred()) SWIG_fail;
48677 }
48678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48679 return resultobj;
48680 fail:
48681 return NULL;
48682 }
48683
48684
48685 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48686 PyObject *resultobj = 0;
48687 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48688 wxStaticBox *result = 0 ;
48689 void *argp1 = 0 ;
48690 int res1 = 0 ;
48691 PyObject *swig_obj[1] ;
48692
48693 if (!args) SWIG_fail;
48694 swig_obj[0] = args;
48695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48696 if (!SWIG_IsOK(res1)) {
48697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48698 }
48699 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48700 {
48701 PyThreadState* __tstate = wxPyBeginAllowThreads();
48702 result = (wxStaticBox *)(arg1)->GetStaticBox();
48703 wxPyEndAllowThreads(__tstate);
48704 if (PyErr_Occurred()) SWIG_fail;
48705 }
48706 {
48707 resultobj = wxPyMake_wxObject(result, (bool)0);
48708 }
48709 return resultobj;
48710 fail:
48711 return NULL;
48712 }
48713
48714
48715 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48716 PyObject *obj;
48717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48718 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48719 return SWIG_Py_Void();
48720 }
48721
48722 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48723 return SWIG_Python_InitShadowInstance(args);
48724 }
48725
48726 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48727 PyObject *resultobj = 0;
48728 int arg1 = (int) 1 ;
48729 int arg2 = (int) 0 ;
48730 int arg3 = (int) 0 ;
48731 int arg4 = (int) 0 ;
48732 wxGridSizer *result = 0 ;
48733 int val1 ;
48734 int ecode1 = 0 ;
48735 int val2 ;
48736 int ecode2 = 0 ;
48737 int val3 ;
48738 int ecode3 = 0 ;
48739 int val4 ;
48740 int ecode4 = 0 ;
48741 PyObject * obj0 = 0 ;
48742 PyObject * obj1 = 0 ;
48743 PyObject * obj2 = 0 ;
48744 PyObject * obj3 = 0 ;
48745 char * kwnames[] = {
48746 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48747 };
48748
48749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48750 if (obj0) {
48751 ecode1 = SWIG_AsVal_int(obj0, &val1);
48752 if (!SWIG_IsOK(ecode1)) {
48753 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48754 }
48755 arg1 = static_cast< int >(val1);
48756 }
48757 if (obj1) {
48758 ecode2 = SWIG_AsVal_int(obj1, &val2);
48759 if (!SWIG_IsOK(ecode2)) {
48760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48761 }
48762 arg2 = static_cast< int >(val2);
48763 }
48764 if (obj2) {
48765 ecode3 = SWIG_AsVal_int(obj2, &val3);
48766 if (!SWIG_IsOK(ecode3)) {
48767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48768 }
48769 arg3 = static_cast< int >(val3);
48770 }
48771 if (obj3) {
48772 ecode4 = SWIG_AsVal_int(obj3, &val4);
48773 if (!SWIG_IsOK(ecode4)) {
48774 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48775 }
48776 arg4 = static_cast< int >(val4);
48777 }
48778 {
48779 PyThreadState* __tstate = wxPyBeginAllowThreads();
48780 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48781 wxPyEndAllowThreads(__tstate);
48782 if (PyErr_Occurred()) SWIG_fail;
48783 }
48784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48785 return resultobj;
48786 fail:
48787 return NULL;
48788 }
48789
48790
48791 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48792 PyObject *resultobj = 0;
48793 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48794 int arg2 ;
48795 void *argp1 = 0 ;
48796 int res1 = 0 ;
48797 int val2 ;
48798 int ecode2 = 0 ;
48799 PyObject * obj0 = 0 ;
48800 PyObject * obj1 = 0 ;
48801 char * kwnames[] = {
48802 (char *) "self",(char *) "cols", NULL
48803 };
48804
48805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48807 if (!SWIG_IsOK(res1)) {
48808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48809 }
48810 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48811 ecode2 = SWIG_AsVal_int(obj1, &val2);
48812 if (!SWIG_IsOK(ecode2)) {
48813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48814 }
48815 arg2 = static_cast< int >(val2);
48816 {
48817 PyThreadState* __tstate = wxPyBeginAllowThreads();
48818 (arg1)->SetCols(arg2);
48819 wxPyEndAllowThreads(__tstate);
48820 if (PyErr_Occurred()) SWIG_fail;
48821 }
48822 resultobj = SWIG_Py_Void();
48823 return resultobj;
48824 fail:
48825 return NULL;
48826 }
48827
48828
48829 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48830 PyObject *resultobj = 0;
48831 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48832 int arg2 ;
48833 void *argp1 = 0 ;
48834 int res1 = 0 ;
48835 int val2 ;
48836 int ecode2 = 0 ;
48837 PyObject * obj0 = 0 ;
48838 PyObject * obj1 = 0 ;
48839 char * kwnames[] = {
48840 (char *) "self",(char *) "rows", NULL
48841 };
48842
48843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48845 if (!SWIG_IsOK(res1)) {
48846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48847 }
48848 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48849 ecode2 = SWIG_AsVal_int(obj1, &val2);
48850 if (!SWIG_IsOK(ecode2)) {
48851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48852 }
48853 arg2 = static_cast< int >(val2);
48854 {
48855 PyThreadState* __tstate = wxPyBeginAllowThreads();
48856 (arg1)->SetRows(arg2);
48857 wxPyEndAllowThreads(__tstate);
48858 if (PyErr_Occurred()) SWIG_fail;
48859 }
48860 resultobj = SWIG_Py_Void();
48861 return resultobj;
48862 fail:
48863 return NULL;
48864 }
48865
48866
48867 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48868 PyObject *resultobj = 0;
48869 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48870 int arg2 ;
48871 void *argp1 = 0 ;
48872 int res1 = 0 ;
48873 int val2 ;
48874 int ecode2 = 0 ;
48875 PyObject * obj0 = 0 ;
48876 PyObject * obj1 = 0 ;
48877 char * kwnames[] = {
48878 (char *) "self",(char *) "gap", NULL
48879 };
48880
48881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48883 if (!SWIG_IsOK(res1)) {
48884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48885 }
48886 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48887 ecode2 = SWIG_AsVal_int(obj1, &val2);
48888 if (!SWIG_IsOK(ecode2)) {
48889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48890 }
48891 arg2 = static_cast< int >(val2);
48892 {
48893 PyThreadState* __tstate = wxPyBeginAllowThreads();
48894 (arg1)->SetVGap(arg2);
48895 wxPyEndAllowThreads(__tstate);
48896 if (PyErr_Occurred()) SWIG_fail;
48897 }
48898 resultobj = SWIG_Py_Void();
48899 return resultobj;
48900 fail:
48901 return NULL;
48902 }
48903
48904
48905 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48906 PyObject *resultobj = 0;
48907 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48908 int arg2 ;
48909 void *argp1 = 0 ;
48910 int res1 = 0 ;
48911 int val2 ;
48912 int ecode2 = 0 ;
48913 PyObject * obj0 = 0 ;
48914 PyObject * obj1 = 0 ;
48915 char * kwnames[] = {
48916 (char *) "self",(char *) "gap", NULL
48917 };
48918
48919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48921 if (!SWIG_IsOK(res1)) {
48922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48923 }
48924 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48925 ecode2 = SWIG_AsVal_int(obj1, &val2);
48926 if (!SWIG_IsOK(ecode2)) {
48927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48928 }
48929 arg2 = static_cast< int >(val2);
48930 {
48931 PyThreadState* __tstate = wxPyBeginAllowThreads();
48932 (arg1)->SetHGap(arg2);
48933 wxPyEndAllowThreads(__tstate);
48934 if (PyErr_Occurred()) SWIG_fail;
48935 }
48936 resultobj = SWIG_Py_Void();
48937 return resultobj;
48938 fail:
48939 return NULL;
48940 }
48941
48942
48943 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48944 PyObject *resultobj = 0;
48945 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48946 int result;
48947 void *argp1 = 0 ;
48948 int res1 = 0 ;
48949 PyObject *swig_obj[1] ;
48950
48951 if (!args) SWIG_fail;
48952 swig_obj[0] = args;
48953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48954 if (!SWIG_IsOK(res1)) {
48955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48956 }
48957 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48958 {
48959 PyThreadState* __tstate = wxPyBeginAllowThreads();
48960 result = (int)(arg1)->GetCols();
48961 wxPyEndAllowThreads(__tstate);
48962 if (PyErr_Occurred()) SWIG_fail;
48963 }
48964 resultobj = SWIG_From_int(static_cast< int >(result));
48965 return resultobj;
48966 fail:
48967 return NULL;
48968 }
48969
48970
48971 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48972 PyObject *resultobj = 0;
48973 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48974 int result;
48975 void *argp1 = 0 ;
48976 int res1 = 0 ;
48977 PyObject *swig_obj[1] ;
48978
48979 if (!args) SWIG_fail;
48980 swig_obj[0] = args;
48981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48982 if (!SWIG_IsOK(res1)) {
48983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48984 }
48985 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48986 {
48987 PyThreadState* __tstate = wxPyBeginAllowThreads();
48988 result = (int)(arg1)->GetRows();
48989 wxPyEndAllowThreads(__tstate);
48990 if (PyErr_Occurred()) SWIG_fail;
48991 }
48992 resultobj = SWIG_From_int(static_cast< int >(result));
48993 return resultobj;
48994 fail:
48995 return NULL;
48996 }
48997
48998
48999 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49000 PyObject *resultobj = 0;
49001 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49002 int result;
49003 void *argp1 = 0 ;
49004 int res1 = 0 ;
49005 PyObject *swig_obj[1] ;
49006
49007 if (!args) SWIG_fail;
49008 swig_obj[0] = args;
49009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49010 if (!SWIG_IsOK(res1)) {
49011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49012 }
49013 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49014 {
49015 PyThreadState* __tstate = wxPyBeginAllowThreads();
49016 result = (int)(arg1)->GetVGap();
49017 wxPyEndAllowThreads(__tstate);
49018 if (PyErr_Occurred()) SWIG_fail;
49019 }
49020 resultobj = SWIG_From_int(static_cast< int >(result));
49021 return resultobj;
49022 fail:
49023 return NULL;
49024 }
49025
49026
49027 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49028 PyObject *resultobj = 0;
49029 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49030 int result;
49031 void *argp1 = 0 ;
49032 int res1 = 0 ;
49033 PyObject *swig_obj[1] ;
49034
49035 if (!args) SWIG_fail;
49036 swig_obj[0] = args;
49037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49038 if (!SWIG_IsOK(res1)) {
49039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49040 }
49041 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49042 {
49043 PyThreadState* __tstate = wxPyBeginAllowThreads();
49044 result = (int)(arg1)->GetHGap();
49045 wxPyEndAllowThreads(__tstate);
49046 if (PyErr_Occurred()) SWIG_fail;
49047 }
49048 resultobj = SWIG_From_int(static_cast< int >(result));
49049 return resultobj;
49050 fail:
49051 return NULL;
49052 }
49053
49054
49055 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49056 PyObject *obj;
49057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49058 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49059 return SWIG_Py_Void();
49060 }
49061
49062 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49063 return SWIG_Python_InitShadowInstance(args);
49064 }
49065
49066 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49067 PyObject *resultobj = 0;
49068 int arg1 = (int) 1 ;
49069 int arg2 = (int) 0 ;
49070 int arg3 = (int) 0 ;
49071 int arg4 = (int) 0 ;
49072 wxFlexGridSizer *result = 0 ;
49073 int val1 ;
49074 int ecode1 = 0 ;
49075 int val2 ;
49076 int ecode2 = 0 ;
49077 int val3 ;
49078 int ecode3 = 0 ;
49079 int val4 ;
49080 int ecode4 = 0 ;
49081 PyObject * obj0 = 0 ;
49082 PyObject * obj1 = 0 ;
49083 PyObject * obj2 = 0 ;
49084 PyObject * obj3 = 0 ;
49085 char * kwnames[] = {
49086 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49087 };
49088
49089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49090 if (obj0) {
49091 ecode1 = SWIG_AsVal_int(obj0, &val1);
49092 if (!SWIG_IsOK(ecode1)) {
49093 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49094 }
49095 arg1 = static_cast< int >(val1);
49096 }
49097 if (obj1) {
49098 ecode2 = SWIG_AsVal_int(obj1, &val2);
49099 if (!SWIG_IsOK(ecode2)) {
49100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49101 }
49102 arg2 = static_cast< int >(val2);
49103 }
49104 if (obj2) {
49105 ecode3 = SWIG_AsVal_int(obj2, &val3);
49106 if (!SWIG_IsOK(ecode3)) {
49107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49108 }
49109 arg3 = static_cast< int >(val3);
49110 }
49111 if (obj3) {
49112 ecode4 = SWIG_AsVal_int(obj3, &val4);
49113 if (!SWIG_IsOK(ecode4)) {
49114 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49115 }
49116 arg4 = static_cast< int >(val4);
49117 }
49118 {
49119 PyThreadState* __tstate = wxPyBeginAllowThreads();
49120 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49121 wxPyEndAllowThreads(__tstate);
49122 if (PyErr_Occurred()) SWIG_fail;
49123 }
49124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49125 return resultobj;
49126 fail:
49127 return NULL;
49128 }
49129
49130
49131 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49132 PyObject *resultobj = 0;
49133 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49134 size_t arg2 ;
49135 int arg3 = (int) 0 ;
49136 void *argp1 = 0 ;
49137 int res1 = 0 ;
49138 size_t val2 ;
49139 int ecode2 = 0 ;
49140 int val3 ;
49141 int ecode3 = 0 ;
49142 PyObject * obj0 = 0 ;
49143 PyObject * obj1 = 0 ;
49144 PyObject * obj2 = 0 ;
49145 char * kwnames[] = {
49146 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49147 };
49148
49149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49151 if (!SWIG_IsOK(res1)) {
49152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49153 }
49154 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49155 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49156 if (!SWIG_IsOK(ecode2)) {
49157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49158 }
49159 arg2 = static_cast< size_t >(val2);
49160 if (obj2) {
49161 ecode3 = SWIG_AsVal_int(obj2, &val3);
49162 if (!SWIG_IsOK(ecode3)) {
49163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49164 }
49165 arg3 = static_cast< int >(val3);
49166 }
49167 {
49168 PyThreadState* __tstate = wxPyBeginAllowThreads();
49169 (arg1)->AddGrowableRow(arg2,arg3);
49170 wxPyEndAllowThreads(__tstate);
49171 if (PyErr_Occurred()) SWIG_fail;
49172 }
49173 resultobj = SWIG_Py_Void();
49174 return resultobj;
49175 fail:
49176 return NULL;
49177 }
49178
49179
49180 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49181 PyObject *resultobj = 0;
49182 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49183 size_t arg2 ;
49184 void *argp1 = 0 ;
49185 int res1 = 0 ;
49186 size_t val2 ;
49187 int ecode2 = 0 ;
49188 PyObject * obj0 = 0 ;
49189 PyObject * obj1 = 0 ;
49190 char * kwnames[] = {
49191 (char *) "self",(char *) "idx", NULL
49192 };
49193
49194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49196 if (!SWIG_IsOK(res1)) {
49197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49198 }
49199 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49200 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49201 if (!SWIG_IsOK(ecode2)) {
49202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49203 }
49204 arg2 = static_cast< size_t >(val2);
49205 {
49206 PyThreadState* __tstate = wxPyBeginAllowThreads();
49207 (arg1)->RemoveGrowableRow(arg2);
49208 wxPyEndAllowThreads(__tstate);
49209 if (PyErr_Occurred()) SWIG_fail;
49210 }
49211 resultobj = SWIG_Py_Void();
49212 return resultobj;
49213 fail:
49214 return NULL;
49215 }
49216
49217
49218 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49219 PyObject *resultobj = 0;
49220 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49221 size_t arg2 ;
49222 int arg3 = (int) 0 ;
49223 void *argp1 = 0 ;
49224 int res1 = 0 ;
49225 size_t val2 ;
49226 int ecode2 = 0 ;
49227 int val3 ;
49228 int ecode3 = 0 ;
49229 PyObject * obj0 = 0 ;
49230 PyObject * obj1 = 0 ;
49231 PyObject * obj2 = 0 ;
49232 char * kwnames[] = {
49233 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49234 };
49235
49236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49238 if (!SWIG_IsOK(res1)) {
49239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49240 }
49241 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49242 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49243 if (!SWIG_IsOK(ecode2)) {
49244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49245 }
49246 arg2 = static_cast< size_t >(val2);
49247 if (obj2) {
49248 ecode3 = SWIG_AsVal_int(obj2, &val3);
49249 if (!SWIG_IsOK(ecode3)) {
49250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49251 }
49252 arg3 = static_cast< int >(val3);
49253 }
49254 {
49255 PyThreadState* __tstate = wxPyBeginAllowThreads();
49256 (arg1)->AddGrowableCol(arg2,arg3);
49257 wxPyEndAllowThreads(__tstate);
49258 if (PyErr_Occurred()) SWIG_fail;
49259 }
49260 resultobj = SWIG_Py_Void();
49261 return resultobj;
49262 fail:
49263 return NULL;
49264 }
49265
49266
49267 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49268 PyObject *resultobj = 0;
49269 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49270 size_t arg2 ;
49271 void *argp1 = 0 ;
49272 int res1 = 0 ;
49273 size_t val2 ;
49274 int ecode2 = 0 ;
49275 PyObject * obj0 = 0 ;
49276 PyObject * obj1 = 0 ;
49277 char * kwnames[] = {
49278 (char *) "self",(char *) "idx", NULL
49279 };
49280
49281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49283 if (!SWIG_IsOK(res1)) {
49284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49285 }
49286 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49287 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49288 if (!SWIG_IsOK(ecode2)) {
49289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49290 }
49291 arg2 = static_cast< size_t >(val2);
49292 {
49293 PyThreadState* __tstate = wxPyBeginAllowThreads();
49294 (arg1)->RemoveGrowableCol(arg2);
49295 wxPyEndAllowThreads(__tstate);
49296 if (PyErr_Occurred()) SWIG_fail;
49297 }
49298 resultobj = SWIG_Py_Void();
49299 return resultobj;
49300 fail:
49301 return NULL;
49302 }
49303
49304
49305 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49306 PyObject *resultobj = 0;
49307 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49308 int arg2 ;
49309 void *argp1 = 0 ;
49310 int res1 = 0 ;
49311 int val2 ;
49312 int ecode2 = 0 ;
49313 PyObject * obj0 = 0 ;
49314 PyObject * obj1 = 0 ;
49315 char * kwnames[] = {
49316 (char *) "self",(char *) "direction", NULL
49317 };
49318
49319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49321 if (!SWIG_IsOK(res1)) {
49322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49323 }
49324 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49325 ecode2 = SWIG_AsVal_int(obj1, &val2);
49326 if (!SWIG_IsOK(ecode2)) {
49327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49328 }
49329 arg2 = static_cast< int >(val2);
49330 {
49331 PyThreadState* __tstate = wxPyBeginAllowThreads();
49332 (arg1)->SetFlexibleDirection(arg2);
49333 wxPyEndAllowThreads(__tstate);
49334 if (PyErr_Occurred()) SWIG_fail;
49335 }
49336 resultobj = SWIG_Py_Void();
49337 return resultobj;
49338 fail:
49339 return NULL;
49340 }
49341
49342
49343 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49344 PyObject *resultobj = 0;
49345 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49346 int result;
49347 void *argp1 = 0 ;
49348 int res1 = 0 ;
49349 PyObject *swig_obj[1] ;
49350
49351 if (!args) SWIG_fail;
49352 swig_obj[0] = args;
49353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49354 if (!SWIG_IsOK(res1)) {
49355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49356 }
49357 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49358 {
49359 PyThreadState* __tstate = wxPyBeginAllowThreads();
49360 result = (int)(arg1)->GetFlexibleDirection();
49361 wxPyEndAllowThreads(__tstate);
49362 if (PyErr_Occurred()) SWIG_fail;
49363 }
49364 resultobj = SWIG_From_int(static_cast< int >(result));
49365 return resultobj;
49366 fail:
49367 return NULL;
49368 }
49369
49370
49371 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49372 PyObject *resultobj = 0;
49373 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49374 wxFlexSizerGrowMode arg2 ;
49375 void *argp1 = 0 ;
49376 int res1 = 0 ;
49377 int val2 ;
49378 int ecode2 = 0 ;
49379 PyObject * obj0 = 0 ;
49380 PyObject * obj1 = 0 ;
49381 char * kwnames[] = {
49382 (char *) "self",(char *) "mode", NULL
49383 };
49384
49385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49387 if (!SWIG_IsOK(res1)) {
49388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49389 }
49390 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49391 ecode2 = SWIG_AsVal_int(obj1, &val2);
49392 if (!SWIG_IsOK(ecode2)) {
49393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49394 }
49395 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49396 {
49397 PyThreadState* __tstate = wxPyBeginAllowThreads();
49398 (arg1)->SetNonFlexibleGrowMode(arg2);
49399 wxPyEndAllowThreads(__tstate);
49400 if (PyErr_Occurred()) SWIG_fail;
49401 }
49402 resultobj = SWIG_Py_Void();
49403 return resultobj;
49404 fail:
49405 return NULL;
49406 }
49407
49408
49409 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49410 PyObject *resultobj = 0;
49411 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49412 wxFlexSizerGrowMode result;
49413 void *argp1 = 0 ;
49414 int res1 = 0 ;
49415 PyObject *swig_obj[1] ;
49416
49417 if (!args) SWIG_fail;
49418 swig_obj[0] = args;
49419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49420 if (!SWIG_IsOK(res1)) {
49421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49422 }
49423 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49424 {
49425 PyThreadState* __tstate = wxPyBeginAllowThreads();
49426 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49427 wxPyEndAllowThreads(__tstate);
49428 if (PyErr_Occurred()) SWIG_fail;
49429 }
49430 resultobj = SWIG_From_int(static_cast< int >(result));
49431 return resultobj;
49432 fail:
49433 return NULL;
49434 }
49435
49436
49437 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49438 PyObject *resultobj = 0;
49439 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49440 wxArrayInt *result = 0 ;
49441 void *argp1 = 0 ;
49442 int res1 = 0 ;
49443 PyObject *swig_obj[1] ;
49444
49445 if (!args) SWIG_fail;
49446 swig_obj[0] = args;
49447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49448 if (!SWIG_IsOK(res1)) {
49449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49450 }
49451 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49452 {
49453 PyThreadState* __tstate = wxPyBeginAllowThreads();
49454 {
49455 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49456 result = (wxArrayInt *) &_result_ref;
49457 }
49458 wxPyEndAllowThreads(__tstate);
49459 if (PyErr_Occurred()) SWIG_fail;
49460 }
49461 {
49462 resultobj = PyList_New(0);
49463 size_t idx;
49464 for (idx = 0; idx < result->GetCount(); idx += 1) {
49465 PyObject* val = PyInt_FromLong( result->Item(idx) );
49466 PyList_Append(resultobj, val);
49467 Py_DECREF(val);
49468 }
49469 }
49470 return resultobj;
49471 fail:
49472 return NULL;
49473 }
49474
49475
49476 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49477 PyObject *resultobj = 0;
49478 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49479 wxArrayInt *result = 0 ;
49480 void *argp1 = 0 ;
49481 int res1 = 0 ;
49482 PyObject *swig_obj[1] ;
49483
49484 if (!args) SWIG_fail;
49485 swig_obj[0] = args;
49486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49487 if (!SWIG_IsOK(res1)) {
49488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49489 }
49490 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49491 {
49492 PyThreadState* __tstate = wxPyBeginAllowThreads();
49493 {
49494 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49495 result = (wxArrayInt *) &_result_ref;
49496 }
49497 wxPyEndAllowThreads(__tstate);
49498 if (PyErr_Occurred()) SWIG_fail;
49499 }
49500 {
49501 resultobj = PyList_New(0);
49502 size_t idx;
49503 for (idx = 0; idx < result->GetCount(); idx += 1) {
49504 PyObject* val = PyInt_FromLong( result->Item(idx) );
49505 PyList_Append(resultobj, val);
49506 Py_DECREF(val);
49507 }
49508 }
49509 return resultobj;
49510 fail:
49511 return NULL;
49512 }
49513
49514
49515 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49516 PyObject *obj;
49517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49518 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49519 return SWIG_Py_Void();
49520 }
49521
49522 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49523 return SWIG_Python_InitShadowInstance(args);
49524 }
49525
49526 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49527 PyObject *resultobj = 0;
49528 wxStdDialogButtonSizer *result = 0 ;
49529
49530 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49531 {
49532 PyThreadState* __tstate = wxPyBeginAllowThreads();
49533 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49534 wxPyEndAllowThreads(__tstate);
49535 if (PyErr_Occurred()) SWIG_fail;
49536 }
49537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49538 return resultobj;
49539 fail:
49540 return NULL;
49541 }
49542
49543
49544 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49545 PyObject *resultobj = 0;
49546 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49547 wxButton *arg2 = (wxButton *) 0 ;
49548 void *argp1 = 0 ;
49549 int res1 = 0 ;
49550 void *argp2 = 0 ;
49551 int res2 = 0 ;
49552 PyObject * obj0 = 0 ;
49553 PyObject * obj1 = 0 ;
49554 char * kwnames[] = {
49555 (char *) "self",(char *) "button", NULL
49556 };
49557
49558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49560 if (!SWIG_IsOK(res1)) {
49561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49562 }
49563 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49564 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49565 if (!SWIG_IsOK(res2)) {
49566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49567 }
49568 arg2 = reinterpret_cast< wxButton * >(argp2);
49569 {
49570 PyThreadState* __tstate = wxPyBeginAllowThreads();
49571 (arg1)->AddButton(arg2);
49572 wxPyEndAllowThreads(__tstate);
49573 if (PyErr_Occurred()) SWIG_fail;
49574 }
49575 resultobj = SWIG_Py_Void();
49576 return resultobj;
49577 fail:
49578 return NULL;
49579 }
49580
49581
49582 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49583 PyObject *resultobj = 0;
49584 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49585 void *argp1 = 0 ;
49586 int res1 = 0 ;
49587 PyObject *swig_obj[1] ;
49588
49589 if (!args) SWIG_fail;
49590 swig_obj[0] = args;
49591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49592 if (!SWIG_IsOK(res1)) {
49593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49594 }
49595 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49596 {
49597 PyThreadState* __tstate = wxPyBeginAllowThreads();
49598 (arg1)->Realize();
49599 wxPyEndAllowThreads(__tstate);
49600 if (PyErr_Occurred()) SWIG_fail;
49601 }
49602 resultobj = SWIG_Py_Void();
49603 return resultobj;
49604 fail:
49605 return NULL;
49606 }
49607
49608
49609 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49610 PyObject *resultobj = 0;
49611 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49612 wxButton *arg2 = (wxButton *) 0 ;
49613 void *argp1 = 0 ;
49614 int res1 = 0 ;
49615 void *argp2 = 0 ;
49616 int res2 = 0 ;
49617 PyObject * obj0 = 0 ;
49618 PyObject * obj1 = 0 ;
49619 char * kwnames[] = {
49620 (char *) "self",(char *) "button", NULL
49621 };
49622
49623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49625 if (!SWIG_IsOK(res1)) {
49626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49627 }
49628 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49629 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49630 if (!SWIG_IsOK(res2)) {
49631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49632 }
49633 arg2 = reinterpret_cast< wxButton * >(argp2);
49634 {
49635 PyThreadState* __tstate = wxPyBeginAllowThreads();
49636 (arg1)->SetAffirmativeButton(arg2);
49637 wxPyEndAllowThreads(__tstate);
49638 if (PyErr_Occurred()) SWIG_fail;
49639 }
49640 resultobj = SWIG_Py_Void();
49641 return resultobj;
49642 fail:
49643 return NULL;
49644 }
49645
49646
49647 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49648 PyObject *resultobj = 0;
49649 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49650 wxButton *arg2 = (wxButton *) 0 ;
49651 void *argp1 = 0 ;
49652 int res1 = 0 ;
49653 void *argp2 = 0 ;
49654 int res2 = 0 ;
49655 PyObject * obj0 = 0 ;
49656 PyObject * obj1 = 0 ;
49657 char * kwnames[] = {
49658 (char *) "self",(char *) "button", NULL
49659 };
49660
49661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49663 if (!SWIG_IsOK(res1)) {
49664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49665 }
49666 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49667 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49668 if (!SWIG_IsOK(res2)) {
49669 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49670 }
49671 arg2 = reinterpret_cast< wxButton * >(argp2);
49672 {
49673 PyThreadState* __tstate = wxPyBeginAllowThreads();
49674 (arg1)->SetNegativeButton(arg2);
49675 wxPyEndAllowThreads(__tstate);
49676 if (PyErr_Occurred()) SWIG_fail;
49677 }
49678 resultobj = SWIG_Py_Void();
49679 return resultobj;
49680 fail:
49681 return NULL;
49682 }
49683
49684
49685 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49686 PyObject *resultobj = 0;
49687 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49688 wxButton *arg2 = (wxButton *) 0 ;
49689 void *argp1 = 0 ;
49690 int res1 = 0 ;
49691 void *argp2 = 0 ;
49692 int res2 = 0 ;
49693 PyObject * obj0 = 0 ;
49694 PyObject * obj1 = 0 ;
49695 char * kwnames[] = {
49696 (char *) "self",(char *) "button", NULL
49697 };
49698
49699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49701 if (!SWIG_IsOK(res1)) {
49702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49703 }
49704 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49705 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49706 if (!SWIG_IsOK(res2)) {
49707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49708 }
49709 arg2 = reinterpret_cast< wxButton * >(argp2);
49710 {
49711 PyThreadState* __tstate = wxPyBeginAllowThreads();
49712 (arg1)->SetCancelButton(arg2);
49713 wxPyEndAllowThreads(__tstate);
49714 if (PyErr_Occurred()) SWIG_fail;
49715 }
49716 resultobj = SWIG_Py_Void();
49717 return resultobj;
49718 fail:
49719 return NULL;
49720 }
49721
49722
49723 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49724 PyObject *resultobj = 0;
49725 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49726 wxButton *result = 0 ;
49727 void *argp1 = 0 ;
49728 int res1 = 0 ;
49729 PyObject *swig_obj[1] ;
49730
49731 if (!args) SWIG_fail;
49732 swig_obj[0] = args;
49733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49734 if (!SWIG_IsOK(res1)) {
49735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49736 }
49737 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49738 {
49739 PyThreadState* __tstate = wxPyBeginAllowThreads();
49740 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49741 wxPyEndAllowThreads(__tstate);
49742 if (PyErr_Occurred()) SWIG_fail;
49743 }
49744 {
49745 resultobj = wxPyMake_wxObject(result, (bool)0);
49746 }
49747 return resultobj;
49748 fail:
49749 return NULL;
49750 }
49751
49752
49753 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49754 PyObject *resultobj = 0;
49755 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49756 wxButton *result = 0 ;
49757 void *argp1 = 0 ;
49758 int res1 = 0 ;
49759 PyObject *swig_obj[1] ;
49760
49761 if (!args) SWIG_fail;
49762 swig_obj[0] = args;
49763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49764 if (!SWIG_IsOK(res1)) {
49765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49766 }
49767 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49768 {
49769 PyThreadState* __tstate = wxPyBeginAllowThreads();
49770 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49771 wxPyEndAllowThreads(__tstate);
49772 if (PyErr_Occurred()) SWIG_fail;
49773 }
49774 {
49775 resultobj = wxPyMake_wxObject(result, (bool)0);
49776 }
49777 return resultobj;
49778 fail:
49779 return NULL;
49780 }
49781
49782
49783 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49784 PyObject *resultobj = 0;
49785 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49786 wxButton *result = 0 ;
49787 void *argp1 = 0 ;
49788 int res1 = 0 ;
49789 PyObject *swig_obj[1] ;
49790
49791 if (!args) SWIG_fail;
49792 swig_obj[0] = args;
49793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49794 if (!SWIG_IsOK(res1)) {
49795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49796 }
49797 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49798 {
49799 PyThreadState* __tstate = wxPyBeginAllowThreads();
49800 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49801 wxPyEndAllowThreads(__tstate);
49802 if (PyErr_Occurred()) SWIG_fail;
49803 }
49804 {
49805 resultobj = wxPyMake_wxObject(result, (bool)0);
49806 }
49807 return resultobj;
49808 fail:
49809 return NULL;
49810 }
49811
49812
49813 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49814 PyObject *resultobj = 0;
49815 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49816 wxButton *result = 0 ;
49817 void *argp1 = 0 ;
49818 int res1 = 0 ;
49819 PyObject *swig_obj[1] ;
49820
49821 if (!args) SWIG_fail;
49822 swig_obj[0] = args;
49823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49824 if (!SWIG_IsOK(res1)) {
49825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49826 }
49827 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49828 {
49829 PyThreadState* __tstate = wxPyBeginAllowThreads();
49830 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49831 wxPyEndAllowThreads(__tstate);
49832 if (PyErr_Occurred()) SWIG_fail;
49833 }
49834 {
49835 resultobj = wxPyMake_wxObject(result, (bool)0);
49836 }
49837 return resultobj;
49838 fail:
49839 return NULL;
49840 }
49841
49842
49843 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49844 PyObject *resultobj = 0;
49845 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49846 wxButton *result = 0 ;
49847 void *argp1 = 0 ;
49848 int res1 = 0 ;
49849 PyObject *swig_obj[1] ;
49850
49851 if (!args) SWIG_fail;
49852 swig_obj[0] = args;
49853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49854 if (!SWIG_IsOK(res1)) {
49855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49856 }
49857 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49858 {
49859 PyThreadState* __tstate = wxPyBeginAllowThreads();
49860 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49861 wxPyEndAllowThreads(__tstate);
49862 if (PyErr_Occurred()) SWIG_fail;
49863 }
49864 {
49865 resultobj = wxPyMake_wxObject(result, (bool)0);
49866 }
49867 return resultobj;
49868 fail:
49869 return NULL;
49870 }
49871
49872
49873 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49874 PyObject *obj;
49875 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49876 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49877 return SWIG_Py_Void();
49878 }
49879
49880 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49881 return SWIG_Python_InitShadowInstance(args);
49882 }
49883
49884 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49885 PyObject *resultobj = 0;
49886 int arg1 = (int) 0 ;
49887 int arg2 = (int) 0 ;
49888 wxGBPosition *result = 0 ;
49889 int val1 ;
49890 int ecode1 = 0 ;
49891 int val2 ;
49892 int ecode2 = 0 ;
49893 PyObject * obj0 = 0 ;
49894 PyObject * obj1 = 0 ;
49895 char * kwnames[] = {
49896 (char *) "row",(char *) "col", NULL
49897 };
49898
49899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49900 if (obj0) {
49901 ecode1 = SWIG_AsVal_int(obj0, &val1);
49902 if (!SWIG_IsOK(ecode1)) {
49903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49904 }
49905 arg1 = static_cast< int >(val1);
49906 }
49907 if (obj1) {
49908 ecode2 = SWIG_AsVal_int(obj1, &val2);
49909 if (!SWIG_IsOK(ecode2)) {
49910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49911 }
49912 arg2 = static_cast< int >(val2);
49913 }
49914 {
49915 PyThreadState* __tstate = wxPyBeginAllowThreads();
49916 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49917 wxPyEndAllowThreads(__tstate);
49918 if (PyErr_Occurred()) SWIG_fail;
49919 }
49920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49921 return resultobj;
49922 fail:
49923 return NULL;
49924 }
49925
49926
49927 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49928 PyObject *resultobj = 0;
49929 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49930 void *argp1 = 0 ;
49931 int res1 = 0 ;
49932 PyObject *swig_obj[1] ;
49933
49934 if (!args) SWIG_fail;
49935 swig_obj[0] = args;
49936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49937 if (!SWIG_IsOK(res1)) {
49938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49939 }
49940 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49941 {
49942 PyThreadState* __tstate = wxPyBeginAllowThreads();
49943 delete arg1;
49944
49945 wxPyEndAllowThreads(__tstate);
49946 if (PyErr_Occurred()) SWIG_fail;
49947 }
49948 resultobj = SWIG_Py_Void();
49949 return resultobj;
49950 fail:
49951 return NULL;
49952 }
49953
49954
49955 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49956 PyObject *resultobj = 0;
49957 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49958 int result;
49959 void *argp1 = 0 ;
49960 int res1 = 0 ;
49961 PyObject *swig_obj[1] ;
49962
49963 if (!args) SWIG_fail;
49964 swig_obj[0] = args;
49965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49966 if (!SWIG_IsOK(res1)) {
49967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49968 }
49969 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49970 {
49971 PyThreadState* __tstate = wxPyBeginAllowThreads();
49972 result = (int)((wxGBPosition const *)arg1)->GetRow();
49973 wxPyEndAllowThreads(__tstate);
49974 if (PyErr_Occurred()) SWIG_fail;
49975 }
49976 resultobj = SWIG_From_int(static_cast< int >(result));
49977 return resultobj;
49978 fail:
49979 return NULL;
49980 }
49981
49982
49983 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49984 PyObject *resultobj = 0;
49985 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49986 int result;
49987 void *argp1 = 0 ;
49988 int res1 = 0 ;
49989 PyObject *swig_obj[1] ;
49990
49991 if (!args) SWIG_fail;
49992 swig_obj[0] = args;
49993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49994 if (!SWIG_IsOK(res1)) {
49995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49996 }
49997 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49998 {
49999 PyThreadState* __tstate = wxPyBeginAllowThreads();
50000 result = (int)((wxGBPosition const *)arg1)->GetCol();
50001 wxPyEndAllowThreads(__tstate);
50002 if (PyErr_Occurred()) SWIG_fail;
50003 }
50004 resultobj = SWIG_From_int(static_cast< int >(result));
50005 return resultobj;
50006 fail:
50007 return NULL;
50008 }
50009
50010
50011 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50012 PyObject *resultobj = 0;
50013 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50014 int arg2 ;
50015 void *argp1 = 0 ;
50016 int res1 = 0 ;
50017 int val2 ;
50018 int ecode2 = 0 ;
50019 PyObject * obj0 = 0 ;
50020 PyObject * obj1 = 0 ;
50021 char * kwnames[] = {
50022 (char *) "self",(char *) "row", NULL
50023 };
50024
50025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50027 if (!SWIG_IsOK(res1)) {
50028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50029 }
50030 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50031 ecode2 = SWIG_AsVal_int(obj1, &val2);
50032 if (!SWIG_IsOK(ecode2)) {
50033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50034 }
50035 arg2 = static_cast< int >(val2);
50036 {
50037 PyThreadState* __tstate = wxPyBeginAllowThreads();
50038 (arg1)->SetRow(arg2);
50039 wxPyEndAllowThreads(__tstate);
50040 if (PyErr_Occurred()) SWIG_fail;
50041 }
50042 resultobj = SWIG_Py_Void();
50043 return resultobj;
50044 fail:
50045 return NULL;
50046 }
50047
50048
50049 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50050 PyObject *resultobj = 0;
50051 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50052 int arg2 ;
50053 void *argp1 = 0 ;
50054 int res1 = 0 ;
50055 int val2 ;
50056 int ecode2 = 0 ;
50057 PyObject * obj0 = 0 ;
50058 PyObject * obj1 = 0 ;
50059 char * kwnames[] = {
50060 (char *) "self",(char *) "col", NULL
50061 };
50062
50063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50065 if (!SWIG_IsOK(res1)) {
50066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50067 }
50068 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50069 ecode2 = SWIG_AsVal_int(obj1, &val2);
50070 if (!SWIG_IsOK(ecode2)) {
50071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50072 }
50073 arg2 = static_cast< int >(val2);
50074 {
50075 PyThreadState* __tstate = wxPyBeginAllowThreads();
50076 (arg1)->SetCol(arg2);
50077 wxPyEndAllowThreads(__tstate);
50078 if (PyErr_Occurred()) SWIG_fail;
50079 }
50080 resultobj = SWIG_Py_Void();
50081 return resultobj;
50082 fail:
50083 return NULL;
50084 }
50085
50086
50087 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50088 PyObject *resultobj = 0;
50089 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50090 PyObject *arg2 = (PyObject *) 0 ;
50091 bool result;
50092 void *argp1 = 0 ;
50093 int res1 = 0 ;
50094 PyObject * obj0 = 0 ;
50095 PyObject * obj1 = 0 ;
50096 char * kwnames[] = {
50097 (char *) "self",(char *) "other", NULL
50098 };
50099
50100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50102 if (!SWIG_IsOK(res1)) {
50103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50104 }
50105 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50106 arg2 = obj1;
50107 {
50108 result = (bool)wxGBPosition___eq__(arg1,arg2);
50109 if (PyErr_Occurred()) SWIG_fail;
50110 }
50111 {
50112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50113 }
50114 return resultobj;
50115 fail:
50116 return NULL;
50117 }
50118
50119
50120 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50121 PyObject *resultobj = 0;
50122 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50123 PyObject *arg2 = (PyObject *) 0 ;
50124 bool result;
50125 void *argp1 = 0 ;
50126 int res1 = 0 ;
50127 PyObject * obj0 = 0 ;
50128 PyObject * obj1 = 0 ;
50129 char * kwnames[] = {
50130 (char *) "self",(char *) "other", NULL
50131 };
50132
50133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50135 if (!SWIG_IsOK(res1)) {
50136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50137 }
50138 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50139 arg2 = obj1;
50140 {
50141 result = (bool)wxGBPosition___ne__(arg1,arg2);
50142 if (PyErr_Occurred()) SWIG_fail;
50143 }
50144 {
50145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50146 }
50147 return resultobj;
50148 fail:
50149 return NULL;
50150 }
50151
50152
50153 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50154 PyObject *resultobj = 0;
50155 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50156 int arg2 = (int) 0 ;
50157 int arg3 = (int) 0 ;
50158 void *argp1 = 0 ;
50159 int res1 = 0 ;
50160 int val2 ;
50161 int ecode2 = 0 ;
50162 int val3 ;
50163 int ecode3 = 0 ;
50164 PyObject * obj0 = 0 ;
50165 PyObject * obj1 = 0 ;
50166 PyObject * obj2 = 0 ;
50167 char * kwnames[] = {
50168 (char *) "self",(char *) "row",(char *) "col", NULL
50169 };
50170
50171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50173 if (!SWIG_IsOK(res1)) {
50174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50175 }
50176 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50177 if (obj1) {
50178 ecode2 = SWIG_AsVal_int(obj1, &val2);
50179 if (!SWIG_IsOK(ecode2)) {
50180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50181 }
50182 arg2 = static_cast< int >(val2);
50183 }
50184 if (obj2) {
50185 ecode3 = SWIG_AsVal_int(obj2, &val3);
50186 if (!SWIG_IsOK(ecode3)) {
50187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50188 }
50189 arg3 = static_cast< int >(val3);
50190 }
50191 {
50192 PyThreadState* __tstate = wxPyBeginAllowThreads();
50193 wxGBPosition_Set(arg1,arg2,arg3);
50194 wxPyEndAllowThreads(__tstate);
50195 if (PyErr_Occurred()) SWIG_fail;
50196 }
50197 resultobj = SWIG_Py_Void();
50198 return resultobj;
50199 fail:
50200 return NULL;
50201 }
50202
50203
50204 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50205 PyObject *resultobj = 0;
50206 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50207 PyObject *result = 0 ;
50208 void *argp1 = 0 ;
50209 int res1 = 0 ;
50210 PyObject *swig_obj[1] ;
50211
50212 if (!args) SWIG_fail;
50213 swig_obj[0] = args;
50214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50215 if (!SWIG_IsOK(res1)) {
50216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50217 }
50218 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50219 {
50220 PyThreadState* __tstate = wxPyBeginAllowThreads();
50221 result = (PyObject *)wxGBPosition_Get(arg1);
50222 wxPyEndAllowThreads(__tstate);
50223 if (PyErr_Occurred()) SWIG_fail;
50224 }
50225 resultobj = result;
50226 return resultobj;
50227 fail:
50228 return NULL;
50229 }
50230
50231
50232 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50233 PyObject *obj;
50234 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50235 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50236 return SWIG_Py_Void();
50237 }
50238
50239 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50240 return SWIG_Python_InitShadowInstance(args);
50241 }
50242
50243 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50244 PyObject *resultobj = 0;
50245 int arg1 = (int) 1 ;
50246 int arg2 = (int) 1 ;
50247 wxGBSpan *result = 0 ;
50248 int val1 ;
50249 int ecode1 = 0 ;
50250 int val2 ;
50251 int ecode2 = 0 ;
50252 PyObject * obj0 = 0 ;
50253 PyObject * obj1 = 0 ;
50254 char * kwnames[] = {
50255 (char *) "rowspan",(char *) "colspan", NULL
50256 };
50257
50258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50259 if (obj0) {
50260 ecode1 = SWIG_AsVal_int(obj0, &val1);
50261 if (!SWIG_IsOK(ecode1)) {
50262 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50263 }
50264 arg1 = static_cast< int >(val1);
50265 }
50266 if (obj1) {
50267 ecode2 = SWIG_AsVal_int(obj1, &val2);
50268 if (!SWIG_IsOK(ecode2)) {
50269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50270 }
50271 arg2 = static_cast< int >(val2);
50272 }
50273 {
50274 PyThreadState* __tstate = wxPyBeginAllowThreads();
50275 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50276 wxPyEndAllowThreads(__tstate);
50277 if (PyErr_Occurred()) SWIG_fail;
50278 }
50279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50280 return resultobj;
50281 fail:
50282 return NULL;
50283 }
50284
50285
50286 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50287 PyObject *resultobj = 0;
50288 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50289 void *argp1 = 0 ;
50290 int res1 = 0 ;
50291 PyObject *swig_obj[1] ;
50292
50293 if (!args) SWIG_fail;
50294 swig_obj[0] = args;
50295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50296 if (!SWIG_IsOK(res1)) {
50297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50298 }
50299 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50300 {
50301 PyThreadState* __tstate = wxPyBeginAllowThreads();
50302 delete arg1;
50303
50304 wxPyEndAllowThreads(__tstate);
50305 if (PyErr_Occurred()) SWIG_fail;
50306 }
50307 resultobj = SWIG_Py_Void();
50308 return resultobj;
50309 fail:
50310 return NULL;
50311 }
50312
50313
50314 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50315 PyObject *resultobj = 0;
50316 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50317 int result;
50318 void *argp1 = 0 ;
50319 int res1 = 0 ;
50320 PyObject *swig_obj[1] ;
50321
50322 if (!args) SWIG_fail;
50323 swig_obj[0] = args;
50324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50325 if (!SWIG_IsOK(res1)) {
50326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50327 }
50328 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50329 {
50330 PyThreadState* __tstate = wxPyBeginAllowThreads();
50331 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50332 wxPyEndAllowThreads(__tstate);
50333 if (PyErr_Occurred()) SWIG_fail;
50334 }
50335 resultobj = SWIG_From_int(static_cast< int >(result));
50336 return resultobj;
50337 fail:
50338 return NULL;
50339 }
50340
50341
50342 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50343 PyObject *resultobj = 0;
50344 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50345 int result;
50346 void *argp1 = 0 ;
50347 int res1 = 0 ;
50348 PyObject *swig_obj[1] ;
50349
50350 if (!args) SWIG_fail;
50351 swig_obj[0] = args;
50352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50353 if (!SWIG_IsOK(res1)) {
50354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50355 }
50356 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50357 {
50358 PyThreadState* __tstate = wxPyBeginAllowThreads();
50359 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50360 wxPyEndAllowThreads(__tstate);
50361 if (PyErr_Occurred()) SWIG_fail;
50362 }
50363 resultobj = SWIG_From_int(static_cast< int >(result));
50364 return resultobj;
50365 fail:
50366 return NULL;
50367 }
50368
50369
50370 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50371 PyObject *resultobj = 0;
50372 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50373 int arg2 ;
50374 void *argp1 = 0 ;
50375 int res1 = 0 ;
50376 int val2 ;
50377 int ecode2 = 0 ;
50378 PyObject * obj0 = 0 ;
50379 PyObject * obj1 = 0 ;
50380 char * kwnames[] = {
50381 (char *) "self",(char *) "rowspan", NULL
50382 };
50383
50384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50386 if (!SWIG_IsOK(res1)) {
50387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50388 }
50389 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50390 ecode2 = SWIG_AsVal_int(obj1, &val2);
50391 if (!SWIG_IsOK(ecode2)) {
50392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50393 }
50394 arg2 = static_cast< int >(val2);
50395 {
50396 PyThreadState* __tstate = wxPyBeginAllowThreads();
50397 (arg1)->SetRowspan(arg2);
50398 wxPyEndAllowThreads(__tstate);
50399 if (PyErr_Occurred()) SWIG_fail;
50400 }
50401 resultobj = SWIG_Py_Void();
50402 return resultobj;
50403 fail:
50404 return NULL;
50405 }
50406
50407
50408 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50409 PyObject *resultobj = 0;
50410 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50411 int arg2 ;
50412 void *argp1 = 0 ;
50413 int res1 = 0 ;
50414 int val2 ;
50415 int ecode2 = 0 ;
50416 PyObject * obj0 = 0 ;
50417 PyObject * obj1 = 0 ;
50418 char * kwnames[] = {
50419 (char *) "self",(char *) "colspan", NULL
50420 };
50421
50422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50424 if (!SWIG_IsOK(res1)) {
50425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50426 }
50427 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50428 ecode2 = SWIG_AsVal_int(obj1, &val2);
50429 if (!SWIG_IsOK(ecode2)) {
50430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50431 }
50432 arg2 = static_cast< int >(val2);
50433 {
50434 PyThreadState* __tstate = wxPyBeginAllowThreads();
50435 (arg1)->SetColspan(arg2);
50436 wxPyEndAllowThreads(__tstate);
50437 if (PyErr_Occurred()) SWIG_fail;
50438 }
50439 resultobj = SWIG_Py_Void();
50440 return resultobj;
50441 fail:
50442 return NULL;
50443 }
50444
50445
50446 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50447 PyObject *resultobj = 0;
50448 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50449 PyObject *arg2 = (PyObject *) 0 ;
50450 bool result;
50451 void *argp1 = 0 ;
50452 int res1 = 0 ;
50453 PyObject * obj0 = 0 ;
50454 PyObject * obj1 = 0 ;
50455 char * kwnames[] = {
50456 (char *) "self",(char *) "other", NULL
50457 };
50458
50459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50461 if (!SWIG_IsOK(res1)) {
50462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50463 }
50464 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50465 arg2 = obj1;
50466 {
50467 result = (bool)wxGBSpan___eq__(arg1,arg2);
50468 if (PyErr_Occurred()) SWIG_fail;
50469 }
50470 {
50471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50472 }
50473 return resultobj;
50474 fail:
50475 return NULL;
50476 }
50477
50478
50479 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50480 PyObject *resultobj = 0;
50481 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50482 PyObject *arg2 = (PyObject *) 0 ;
50483 bool result;
50484 void *argp1 = 0 ;
50485 int res1 = 0 ;
50486 PyObject * obj0 = 0 ;
50487 PyObject * obj1 = 0 ;
50488 char * kwnames[] = {
50489 (char *) "self",(char *) "other", NULL
50490 };
50491
50492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50494 if (!SWIG_IsOK(res1)) {
50495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50496 }
50497 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50498 arg2 = obj1;
50499 {
50500 result = (bool)wxGBSpan___ne__(arg1,arg2);
50501 if (PyErr_Occurred()) SWIG_fail;
50502 }
50503 {
50504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50505 }
50506 return resultobj;
50507 fail:
50508 return NULL;
50509 }
50510
50511
50512 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50513 PyObject *resultobj = 0;
50514 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50515 int arg2 = (int) 1 ;
50516 int arg3 = (int) 1 ;
50517 void *argp1 = 0 ;
50518 int res1 = 0 ;
50519 int val2 ;
50520 int ecode2 = 0 ;
50521 int val3 ;
50522 int ecode3 = 0 ;
50523 PyObject * obj0 = 0 ;
50524 PyObject * obj1 = 0 ;
50525 PyObject * obj2 = 0 ;
50526 char * kwnames[] = {
50527 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50528 };
50529
50530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50532 if (!SWIG_IsOK(res1)) {
50533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50534 }
50535 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50536 if (obj1) {
50537 ecode2 = SWIG_AsVal_int(obj1, &val2);
50538 if (!SWIG_IsOK(ecode2)) {
50539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50540 }
50541 arg2 = static_cast< int >(val2);
50542 }
50543 if (obj2) {
50544 ecode3 = SWIG_AsVal_int(obj2, &val3);
50545 if (!SWIG_IsOK(ecode3)) {
50546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50547 }
50548 arg3 = static_cast< int >(val3);
50549 }
50550 {
50551 PyThreadState* __tstate = wxPyBeginAllowThreads();
50552 wxGBSpan_Set(arg1,arg2,arg3);
50553 wxPyEndAllowThreads(__tstate);
50554 if (PyErr_Occurred()) SWIG_fail;
50555 }
50556 resultobj = SWIG_Py_Void();
50557 return resultobj;
50558 fail:
50559 return NULL;
50560 }
50561
50562
50563 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50564 PyObject *resultobj = 0;
50565 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50566 PyObject *result = 0 ;
50567 void *argp1 = 0 ;
50568 int res1 = 0 ;
50569 PyObject *swig_obj[1] ;
50570
50571 if (!args) SWIG_fail;
50572 swig_obj[0] = args;
50573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50574 if (!SWIG_IsOK(res1)) {
50575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50576 }
50577 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50578 {
50579 PyThreadState* __tstate = wxPyBeginAllowThreads();
50580 result = (PyObject *)wxGBSpan_Get(arg1);
50581 wxPyEndAllowThreads(__tstate);
50582 if (PyErr_Occurred()) SWIG_fail;
50583 }
50584 resultobj = result;
50585 return resultobj;
50586 fail:
50587 return NULL;
50588 }
50589
50590
50591 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50592 PyObject *obj;
50593 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50594 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50595 return SWIG_Py_Void();
50596 }
50597
50598 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50599 return SWIG_Python_InitShadowInstance(args);
50600 }
50601
50602 SWIGINTERN int DefaultSpan_set(PyObject *) {
50603 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
50604 return 1;
50605 }
50606
50607
50608 SWIGINTERN PyObject *DefaultSpan_get(void) {
50609 PyObject *pyobj = 0;
50610
50611 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
50612 return pyobj;
50613 }
50614
50615
50616 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50617 PyObject *resultobj = 0;
50618 wxGBSizerItem *result = 0 ;
50619
50620 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
50621 {
50622 PyThreadState* __tstate = wxPyBeginAllowThreads();
50623 result = (wxGBSizerItem *)new wxGBSizerItem();
50624 wxPyEndAllowThreads(__tstate);
50625 if (PyErr_Occurred()) SWIG_fail;
50626 }
50627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
50628 return resultobj;
50629 fail:
50630 return NULL;
50631 }
50632
50633
50634 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50635 PyObject *resultobj = 0;
50636 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50637 void *argp1 = 0 ;
50638 int res1 = 0 ;
50639 PyObject *swig_obj[1] ;
50640
50641 if (!args) SWIG_fail;
50642 swig_obj[0] = args;
50643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50644 if (!SWIG_IsOK(res1)) {
50645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50646 }
50647 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50648 {
50649 PyThreadState* __tstate = wxPyBeginAllowThreads();
50650 delete arg1;
50651
50652 wxPyEndAllowThreads(__tstate);
50653 if (PyErr_Occurred()) SWIG_fail;
50654 }
50655 resultobj = SWIG_Py_Void();
50656 return resultobj;
50657 fail:
50658 return NULL;
50659 }
50660
50661
50662 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50663 PyObject *resultobj = 0;
50664 wxWindow *arg1 = (wxWindow *) 0 ;
50665 wxGBPosition *arg2 = 0 ;
50666 wxGBSpan *arg3 = 0 ;
50667 int arg4 ;
50668 int arg5 ;
50669 PyObject *arg6 = (PyObject *) NULL ;
50670 wxGBSizerItem *result = 0 ;
50671 void *argp1 = 0 ;
50672 int res1 = 0 ;
50673 wxGBPosition temp2 ;
50674 wxGBSpan temp3 ;
50675 int val4 ;
50676 int ecode4 = 0 ;
50677 int val5 ;
50678 int ecode5 = 0 ;
50679 PyObject * obj0 = 0 ;
50680 PyObject * obj1 = 0 ;
50681 PyObject * obj2 = 0 ;
50682 PyObject * obj3 = 0 ;
50683 PyObject * obj4 = 0 ;
50684 PyObject * obj5 = 0 ;
50685 char * kwnames[] = {
50686 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50687 };
50688
50689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50691 if (!SWIG_IsOK(res1)) {
50692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50693 }
50694 arg1 = reinterpret_cast< wxWindow * >(argp1);
50695 {
50696 arg2 = &temp2;
50697 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50698 }
50699 {
50700 arg3 = &temp3;
50701 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50702 }
50703 ecode4 = SWIG_AsVal_int(obj3, &val4);
50704 if (!SWIG_IsOK(ecode4)) {
50705 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50706 }
50707 arg4 = static_cast< int >(val4);
50708 ecode5 = SWIG_AsVal_int(obj4, &val5);
50709 if (!SWIG_IsOK(ecode5)) {
50710 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50711 }
50712 arg5 = static_cast< int >(val5);
50713 if (obj5) {
50714 arg6 = obj5;
50715 }
50716 {
50717 PyThreadState* __tstate = wxPyBeginAllowThreads();
50718 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50719 wxPyEndAllowThreads(__tstate);
50720 if (PyErr_Occurred()) SWIG_fail;
50721 }
50722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50723 return resultobj;
50724 fail:
50725 return NULL;
50726 }
50727
50728
50729 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50730 PyObject *resultobj = 0;
50731 wxSizer *arg1 = (wxSizer *) 0 ;
50732 wxGBPosition *arg2 = 0 ;
50733 wxGBSpan *arg3 = 0 ;
50734 int arg4 ;
50735 int arg5 ;
50736 PyObject *arg6 = (PyObject *) NULL ;
50737 wxGBSizerItem *result = 0 ;
50738 int res1 = 0 ;
50739 wxGBPosition temp2 ;
50740 wxGBSpan temp3 ;
50741 int val4 ;
50742 int ecode4 = 0 ;
50743 int val5 ;
50744 int ecode5 = 0 ;
50745 PyObject * obj0 = 0 ;
50746 PyObject * obj1 = 0 ;
50747 PyObject * obj2 = 0 ;
50748 PyObject * obj3 = 0 ;
50749 PyObject * obj4 = 0 ;
50750 PyObject * obj5 = 0 ;
50751 char * kwnames[] = {
50752 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50753 };
50754
50755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50756 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50757 if (!SWIG_IsOK(res1)) {
50758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50759 }
50760 {
50761 arg2 = &temp2;
50762 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50763 }
50764 {
50765 arg3 = &temp3;
50766 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50767 }
50768 ecode4 = SWIG_AsVal_int(obj3, &val4);
50769 if (!SWIG_IsOK(ecode4)) {
50770 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50771 }
50772 arg4 = static_cast< int >(val4);
50773 ecode5 = SWIG_AsVal_int(obj4, &val5);
50774 if (!SWIG_IsOK(ecode5)) {
50775 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50776 }
50777 arg5 = static_cast< int >(val5);
50778 if (obj5) {
50779 arg6 = obj5;
50780 }
50781 {
50782 PyThreadState* __tstate = wxPyBeginAllowThreads();
50783 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50784 wxPyEndAllowThreads(__tstate);
50785 if (PyErr_Occurred()) SWIG_fail;
50786 }
50787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50788 return resultobj;
50789 fail:
50790 return NULL;
50791 }
50792
50793
50794 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50795 PyObject *resultobj = 0;
50796 int arg1 ;
50797 int arg2 ;
50798 wxGBPosition *arg3 = 0 ;
50799 wxGBSpan *arg4 = 0 ;
50800 int arg5 ;
50801 int arg6 ;
50802 PyObject *arg7 = (PyObject *) NULL ;
50803 wxGBSizerItem *result = 0 ;
50804 int val1 ;
50805 int ecode1 = 0 ;
50806 int val2 ;
50807 int ecode2 = 0 ;
50808 wxGBPosition temp3 ;
50809 wxGBSpan temp4 ;
50810 int val5 ;
50811 int ecode5 = 0 ;
50812 int val6 ;
50813 int ecode6 = 0 ;
50814 PyObject * obj0 = 0 ;
50815 PyObject * obj1 = 0 ;
50816 PyObject * obj2 = 0 ;
50817 PyObject * obj3 = 0 ;
50818 PyObject * obj4 = 0 ;
50819 PyObject * obj5 = 0 ;
50820 PyObject * obj6 = 0 ;
50821 char * kwnames[] = {
50822 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50823 };
50824
50825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50826 ecode1 = SWIG_AsVal_int(obj0, &val1);
50827 if (!SWIG_IsOK(ecode1)) {
50828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50829 }
50830 arg1 = static_cast< int >(val1);
50831 ecode2 = SWIG_AsVal_int(obj1, &val2);
50832 if (!SWIG_IsOK(ecode2)) {
50833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50834 }
50835 arg2 = static_cast< int >(val2);
50836 {
50837 arg3 = &temp3;
50838 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50839 }
50840 {
50841 arg4 = &temp4;
50842 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50843 }
50844 ecode5 = SWIG_AsVal_int(obj4, &val5);
50845 if (!SWIG_IsOK(ecode5)) {
50846 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50847 }
50848 arg5 = static_cast< int >(val5);
50849 ecode6 = SWIG_AsVal_int(obj5, &val6);
50850 if (!SWIG_IsOK(ecode6)) {
50851 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50852 }
50853 arg6 = static_cast< int >(val6);
50854 if (obj6) {
50855 arg7 = obj6;
50856 }
50857 {
50858 PyThreadState* __tstate = wxPyBeginAllowThreads();
50859 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50860 wxPyEndAllowThreads(__tstate);
50861 if (PyErr_Occurred()) SWIG_fail;
50862 }
50863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50864 return resultobj;
50865 fail:
50866 return NULL;
50867 }
50868
50869
50870 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50871 PyObject *resultobj = 0;
50872 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50873 wxGBPosition result;
50874 void *argp1 = 0 ;
50875 int res1 = 0 ;
50876 PyObject *swig_obj[1] ;
50877
50878 if (!args) SWIG_fail;
50879 swig_obj[0] = args;
50880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50881 if (!SWIG_IsOK(res1)) {
50882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50883 }
50884 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50885 {
50886 PyThreadState* __tstate = wxPyBeginAllowThreads();
50887 result = ((wxGBSizerItem const *)arg1)->GetPos();
50888 wxPyEndAllowThreads(__tstate);
50889 if (PyErr_Occurred()) SWIG_fail;
50890 }
50891 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50892 return resultobj;
50893 fail:
50894 return NULL;
50895 }
50896
50897
50898 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50899 PyObject *resultobj = 0;
50900 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50901 wxGBSpan result;
50902 void *argp1 = 0 ;
50903 int res1 = 0 ;
50904 PyObject *swig_obj[1] ;
50905
50906 if (!args) SWIG_fail;
50907 swig_obj[0] = args;
50908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50909 if (!SWIG_IsOK(res1)) {
50910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50911 }
50912 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50913 {
50914 PyThreadState* __tstate = wxPyBeginAllowThreads();
50915 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50916 wxPyEndAllowThreads(__tstate);
50917 if (PyErr_Occurred()) SWIG_fail;
50918 }
50919 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50920 return resultobj;
50921 fail:
50922 return NULL;
50923 }
50924
50925
50926 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50927 PyObject *resultobj = 0;
50928 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50929 wxGBPosition *arg2 = 0 ;
50930 bool result;
50931 void *argp1 = 0 ;
50932 int res1 = 0 ;
50933 wxGBPosition temp2 ;
50934 PyObject * obj0 = 0 ;
50935 PyObject * obj1 = 0 ;
50936 char * kwnames[] = {
50937 (char *) "self",(char *) "pos", NULL
50938 };
50939
50940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50942 if (!SWIG_IsOK(res1)) {
50943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50944 }
50945 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50946 {
50947 arg2 = &temp2;
50948 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50949 }
50950 {
50951 PyThreadState* __tstate = wxPyBeginAllowThreads();
50952 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50953 wxPyEndAllowThreads(__tstate);
50954 if (PyErr_Occurred()) SWIG_fail;
50955 }
50956 {
50957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50958 }
50959 return resultobj;
50960 fail:
50961 return NULL;
50962 }
50963
50964
50965 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50966 PyObject *resultobj = 0;
50967 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50968 wxGBSpan *arg2 = 0 ;
50969 bool result;
50970 void *argp1 = 0 ;
50971 int res1 = 0 ;
50972 wxGBSpan temp2 ;
50973 PyObject * obj0 = 0 ;
50974 PyObject * obj1 = 0 ;
50975 char * kwnames[] = {
50976 (char *) "self",(char *) "span", NULL
50977 };
50978
50979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50981 if (!SWIG_IsOK(res1)) {
50982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50983 }
50984 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50985 {
50986 arg2 = &temp2;
50987 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50988 }
50989 {
50990 PyThreadState* __tstate = wxPyBeginAllowThreads();
50991 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50992 wxPyEndAllowThreads(__tstate);
50993 if (PyErr_Occurred()) SWIG_fail;
50994 }
50995 {
50996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50997 }
50998 return resultobj;
50999 fail:
51000 return NULL;
51001 }
51002
51003
51004 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51005 PyObject *resultobj = 0;
51006 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51007 wxGBSizerItem *arg2 = 0 ;
51008 bool result;
51009 void *argp1 = 0 ;
51010 int res1 = 0 ;
51011 void *argp2 = 0 ;
51012 int res2 = 0 ;
51013 PyObject * obj0 = 0 ;
51014 PyObject * obj1 = 0 ;
51015 char * kwnames[] = {
51016 (char *) "self",(char *) "other", NULL
51017 };
51018
51019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51021 if (!SWIG_IsOK(res1)) {
51022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51023 }
51024 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51025 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51026 if (!SWIG_IsOK(res2)) {
51027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51028 }
51029 if (!argp2) {
51030 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51031 }
51032 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51033 {
51034 PyThreadState* __tstate = wxPyBeginAllowThreads();
51035 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51036 wxPyEndAllowThreads(__tstate);
51037 if (PyErr_Occurred()) SWIG_fail;
51038 }
51039 {
51040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51041 }
51042 return resultobj;
51043 fail:
51044 return NULL;
51045 }
51046
51047
51048 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51049 PyObject *resultobj = 0;
51050 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51051 wxGBPosition *arg2 = 0 ;
51052 wxGBSpan *arg3 = 0 ;
51053 bool result;
51054 void *argp1 = 0 ;
51055 int res1 = 0 ;
51056 wxGBPosition temp2 ;
51057 wxGBSpan temp3 ;
51058 PyObject * obj0 = 0 ;
51059 PyObject * obj1 = 0 ;
51060 PyObject * obj2 = 0 ;
51061 char * kwnames[] = {
51062 (char *) "self",(char *) "pos",(char *) "span", NULL
51063 };
51064
51065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51067 if (!SWIG_IsOK(res1)) {
51068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51069 }
51070 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51071 {
51072 arg2 = &temp2;
51073 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51074 }
51075 {
51076 arg3 = &temp3;
51077 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51078 }
51079 {
51080 PyThreadState* __tstate = wxPyBeginAllowThreads();
51081 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51082 wxPyEndAllowThreads(__tstate);
51083 if (PyErr_Occurred()) SWIG_fail;
51084 }
51085 {
51086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51087 }
51088 return resultobj;
51089 fail:
51090 return NULL;
51091 }
51092
51093
51094 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51095 PyObject *resultobj = 0;
51096 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51097 wxGBPosition result;
51098 void *argp1 = 0 ;
51099 int res1 = 0 ;
51100 PyObject *swig_obj[1] ;
51101
51102 if (!args) SWIG_fail;
51103 swig_obj[0] = args;
51104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51105 if (!SWIG_IsOK(res1)) {
51106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51107 }
51108 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51109 {
51110 PyThreadState* __tstate = wxPyBeginAllowThreads();
51111 result = wxGBSizerItem_GetEndPos(arg1);
51112 wxPyEndAllowThreads(__tstate);
51113 if (PyErr_Occurred()) SWIG_fail;
51114 }
51115 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51116 return resultobj;
51117 fail:
51118 return NULL;
51119 }
51120
51121
51122 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51123 PyObject *resultobj = 0;
51124 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51125 wxGridBagSizer *result = 0 ;
51126 void *argp1 = 0 ;
51127 int res1 = 0 ;
51128 PyObject *swig_obj[1] ;
51129
51130 if (!args) SWIG_fail;
51131 swig_obj[0] = args;
51132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51133 if (!SWIG_IsOK(res1)) {
51134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51135 }
51136 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51137 {
51138 PyThreadState* __tstate = wxPyBeginAllowThreads();
51139 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51140 wxPyEndAllowThreads(__tstate);
51141 if (PyErr_Occurred()) SWIG_fail;
51142 }
51143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51144 return resultobj;
51145 fail:
51146 return NULL;
51147 }
51148
51149
51150 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51151 PyObject *resultobj = 0;
51152 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51153 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51154 void *argp1 = 0 ;
51155 int res1 = 0 ;
51156 void *argp2 = 0 ;
51157 int res2 = 0 ;
51158 PyObject * obj0 = 0 ;
51159 PyObject * obj1 = 0 ;
51160 char * kwnames[] = {
51161 (char *) "self",(char *) "sizer", NULL
51162 };
51163
51164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51166 if (!SWIG_IsOK(res1)) {
51167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51168 }
51169 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51170 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51171 if (!SWIG_IsOK(res2)) {
51172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51173 }
51174 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51175 {
51176 PyThreadState* __tstate = wxPyBeginAllowThreads();
51177 (arg1)->SetGBSizer(arg2);
51178 wxPyEndAllowThreads(__tstate);
51179 if (PyErr_Occurred()) SWIG_fail;
51180 }
51181 resultobj = SWIG_Py_Void();
51182 return resultobj;
51183 fail:
51184 return NULL;
51185 }
51186
51187
51188 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51189 PyObject *obj;
51190 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51191 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51192 return SWIG_Py_Void();
51193 }
51194
51195 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51196 return SWIG_Python_InitShadowInstance(args);
51197 }
51198
51199 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51200 PyObject *resultobj = 0;
51201 int arg1 = (int) 0 ;
51202 int arg2 = (int) 0 ;
51203 wxGridBagSizer *result = 0 ;
51204 int val1 ;
51205 int ecode1 = 0 ;
51206 int val2 ;
51207 int ecode2 = 0 ;
51208 PyObject * obj0 = 0 ;
51209 PyObject * obj1 = 0 ;
51210 char * kwnames[] = {
51211 (char *) "vgap",(char *) "hgap", NULL
51212 };
51213
51214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51215 if (obj0) {
51216 ecode1 = SWIG_AsVal_int(obj0, &val1);
51217 if (!SWIG_IsOK(ecode1)) {
51218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51219 }
51220 arg1 = static_cast< int >(val1);
51221 }
51222 if (obj1) {
51223 ecode2 = SWIG_AsVal_int(obj1, &val2);
51224 if (!SWIG_IsOK(ecode2)) {
51225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51226 }
51227 arg2 = static_cast< int >(val2);
51228 }
51229 {
51230 PyThreadState* __tstate = wxPyBeginAllowThreads();
51231 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51232 wxPyEndAllowThreads(__tstate);
51233 if (PyErr_Occurred()) SWIG_fail;
51234 }
51235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51236 return resultobj;
51237 fail:
51238 return NULL;
51239 }
51240
51241
51242 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51243 PyObject *resultobj = 0;
51244 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51245 PyObject *arg2 = (PyObject *) 0 ;
51246 wxGBPosition *arg3 = 0 ;
51247 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51248 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51249 int arg5 = (int) 0 ;
51250 int arg6 = (int) 0 ;
51251 PyObject *arg7 = (PyObject *) NULL ;
51252 wxGBSizerItem *result = 0 ;
51253 void *argp1 = 0 ;
51254 int res1 = 0 ;
51255 wxGBPosition temp3 ;
51256 wxGBSpan temp4 ;
51257 int val5 ;
51258 int ecode5 = 0 ;
51259 int val6 ;
51260 int ecode6 = 0 ;
51261 PyObject * obj0 = 0 ;
51262 PyObject * obj1 = 0 ;
51263 PyObject * obj2 = 0 ;
51264 PyObject * obj3 = 0 ;
51265 PyObject * obj4 = 0 ;
51266 PyObject * obj5 = 0 ;
51267 PyObject * obj6 = 0 ;
51268 char * kwnames[] = {
51269 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51270 };
51271
51272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51274 if (!SWIG_IsOK(res1)) {
51275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51276 }
51277 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51278 arg2 = obj1;
51279 {
51280 arg3 = &temp3;
51281 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51282 }
51283 if (obj3) {
51284 {
51285 arg4 = &temp4;
51286 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51287 }
51288 }
51289 if (obj4) {
51290 ecode5 = SWIG_AsVal_int(obj4, &val5);
51291 if (!SWIG_IsOK(ecode5)) {
51292 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51293 }
51294 arg5 = static_cast< int >(val5);
51295 }
51296 if (obj5) {
51297 ecode6 = SWIG_AsVal_int(obj5, &val6);
51298 if (!SWIG_IsOK(ecode6)) {
51299 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51300 }
51301 arg6 = static_cast< int >(val6);
51302 }
51303 if (obj6) {
51304 arg7 = obj6;
51305 }
51306 {
51307 PyThreadState* __tstate = wxPyBeginAllowThreads();
51308 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51309 wxPyEndAllowThreads(__tstate);
51310 if (PyErr_Occurred()) SWIG_fail;
51311 }
51312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51313 return resultobj;
51314 fail:
51315 return NULL;
51316 }
51317
51318
51319 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51320 PyObject *resultobj = 0;
51321 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51322 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51323 wxGBSizerItem *result = 0 ;
51324 void *argp1 = 0 ;
51325 int res1 = 0 ;
51326 int res2 = 0 ;
51327 PyObject * obj0 = 0 ;
51328 PyObject * obj1 = 0 ;
51329 char * kwnames[] = {
51330 (char *) "self",(char *) "item", NULL
51331 };
51332
51333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51335 if (!SWIG_IsOK(res1)) {
51336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51337 }
51338 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51339 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51340 if (!SWIG_IsOK(res2)) {
51341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51342 }
51343 {
51344 PyThreadState* __tstate = wxPyBeginAllowThreads();
51345 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51346 wxPyEndAllowThreads(__tstate);
51347 if (PyErr_Occurred()) SWIG_fail;
51348 }
51349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51350 return resultobj;
51351 fail:
51352 return NULL;
51353 }
51354
51355
51356 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51357 PyObject *resultobj = 0;
51358 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51359 int arg2 ;
51360 int arg3 ;
51361 wxSize result;
51362 void *argp1 = 0 ;
51363 int res1 = 0 ;
51364 int val2 ;
51365 int ecode2 = 0 ;
51366 int val3 ;
51367 int ecode3 = 0 ;
51368 PyObject * obj0 = 0 ;
51369 PyObject * obj1 = 0 ;
51370 PyObject * obj2 = 0 ;
51371 char * kwnames[] = {
51372 (char *) "self",(char *) "row",(char *) "col", NULL
51373 };
51374
51375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51377 if (!SWIG_IsOK(res1)) {
51378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51379 }
51380 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51381 ecode2 = SWIG_AsVal_int(obj1, &val2);
51382 if (!SWIG_IsOK(ecode2)) {
51383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51384 }
51385 arg2 = static_cast< int >(val2);
51386 ecode3 = SWIG_AsVal_int(obj2, &val3);
51387 if (!SWIG_IsOK(ecode3)) {
51388 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51389 }
51390 arg3 = static_cast< int >(val3);
51391 {
51392 PyThreadState* __tstate = wxPyBeginAllowThreads();
51393 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51394 wxPyEndAllowThreads(__tstate);
51395 if (PyErr_Occurred()) SWIG_fail;
51396 }
51397 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51398 return resultobj;
51399 fail:
51400 return NULL;
51401 }
51402
51403
51404 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51405 PyObject *resultobj = 0;
51406 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51407 wxSize result;
51408 void *argp1 = 0 ;
51409 int res1 = 0 ;
51410 PyObject *swig_obj[1] ;
51411
51412 if (!args) SWIG_fail;
51413 swig_obj[0] = args;
51414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51415 if (!SWIG_IsOK(res1)) {
51416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51417 }
51418 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51419 {
51420 PyThreadState* __tstate = wxPyBeginAllowThreads();
51421 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51422 wxPyEndAllowThreads(__tstate);
51423 if (PyErr_Occurred()) SWIG_fail;
51424 }
51425 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51426 return resultobj;
51427 fail:
51428 return NULL;
51429 }
51430
51431
51432 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51433 PyObject *resultobj = 0;
51434 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51435 wxSize *arg2 = 0 ;
51436 void *argp1 = 0 ;
51437 int res1 = 0 ;
51438 wxSize temp2 ;
51439 PyObject * obj0 = 0 ;
51440 PyObject * obj1 = 0 ;
51441 char * kwnames[] = {
51442 (char *) "self",(char *) "sz", NULL
51443 };
51444
51445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51447 if (!SWIG_IsOK(res1)) {
51448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51449 }
51450 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51451 {
51452 arg2 = &temp2;
51453 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51454 }
51455 {
51456 PyThreadState* __tstate = wxPyBeginAllowThreads();
51457 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51458 wxPyEndAllowThreads(__tstate);
51459 if (PyErr_Occurred()) SWIG_fail;
51460 }
51461 resultobj = SWIG_Py_Void();
51462 return resultobj;
51463 fail:
51464 return NULL;
51465 }
51466
51467
51468 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51469 PyObject *resultobj = 0;
51470 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51471 wxWindow *arg2 = (wxWindow *) 0 ;
51472 wxGBPosition result;
51473 void *argp1 = 0 ;
51474 int res1 = 0 ;
51475 void *argp2 = 0 ;
51476 int res2 = 0 ;
51477
51478 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51480 if (!SWIG_IsOK(res1)) {
51481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51482 }
51483 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51484 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51485 if (!SWIG_IsOK(res2)) {
51486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51487 }
51488 arg2 = reinterpret_cast< wxWindow * >(argp2);
51489 {
51490 PyThreadState* __tstate = wxPyBeginAllowThreads();
51491 result = (arg1)->GetItemPosition(arg2);
51492 wxPyEndAllowThreads(__tstate);
51493 if (PyErr_Occurred()) SWIG_fail;
51494 }
51495 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51496 return resultobj;
51497 fail:
51498 return NULL;
51499 }
51500
51501
51502 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51503 PyObject *resultobj = 0;
51504 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51505 wxSizer *arg2 = (wxSizer *) 0 ;
51506 wxGBPosition result;
51507 void *argp1 = 0 ;
51508 int res1 = 0 ;
51509 void *argp2 = 0 ;
51510 int res2 = 0 ;
51511
51512 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51514 if (!SWIG_IsOK(res1)) {
51515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51516 }
51517 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51518 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51519 if (!SWIG_IsOK(res2)) {
51520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51521 }
51522 arg2 = reinterpret_cast< wxSizer * >(argp2);
51523 {
51524 PyThreadState* __tstate = wxPyBeginAllowThreads();
51525 result = (arg1)->GetItemPosition(arg2);
51526 wxPyEndAllowThreads(__tstate);
51527 if (PyErr_Occurred()) SWIG_fail;
51528 }
51529 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51530 return resultobj;
51531 fail:
51532 return NULL;
51533 }
51534
51535
51536 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51537 PyObject *resultobj = 0;
51538 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51539 size_t arg2 ;
51540 wxGBPosition result;
51541 void *argp1 = 0 ;
51542 int res1 = 0 ;
51543 size_t val2 ;
51544 int ecode2 = 0 ;
51545
51546 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51548 if (!SWIG_IsOK(res1)) {
51549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51550 }
51551 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51552 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51553 if (!SWIG_IsOK(ecode2)) {
51554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51555 }
51556 arg2 = static_cast< size_t >(val2);
51557 {
51558 PyThreadState* __tstate = wxPyBeginAllowThreads();
51559 result = (arg1)->GetItemPosition(arg2);
51560 wxPyEndAllowThreads(__tstate);
51561 if (PyErr_Occurred()) SWIG_fail;
51562 }
51563 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51564 return resultobj;
51565 fail:
51566 return NULL;
51567 }
51568
51569
51570 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51571 int argc;
51572 PyObject *argv[3];
51573
51574 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51575 --argc;
51576 if (argc == 2) {
51577 int _v = 0;
51578 {
51579 void *vptr = 0;
51580 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51581 _v = SWIG_CheckState(res);
51582 }
51583 if (!_v) goto check_1;
51584 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51585 }
51586 check_1:
51587
51588 if (argc == 2) {
51589 int _v = 0;
51590 {
51591 void *vptr = 0;
51592 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51593 _v = SWIG_CheckState(res);
51594 }
51595 if (!_v) goto check_2;
51596 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51597 }
51598 check_2:
51599
51600 if (argc == 2) {
51601 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51602 }
51603
51604 fail:
51605 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
51606 return NULL;
51607 }
51608
51609
51610 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51611 PyObject *resultobj = 0;
51612 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51613 wxWindow *arg2 = (wxWindow *) 0 ;
51614 wxGBPosition *arg3 = 0 ;
51615 bool result;
51616 void *argp1 = 0 ;
51617 int res1 = 0 ;
51618 void *argp2 = 0 ;
51619 int res2 = 0 ;
51620 wxGBPosition temp3 ;
51621
51622 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51624 if (!SWIG_IsOK(res1)) {
51625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51626 }
51627 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51628 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51629 if (!SWIG_IsOK(res2)) {
51630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51631 }
51632 arg2 = reinterpret_cast< wxWindow * >(argp2);
51633 {
51634 arg3 = &temp3;
51635 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51636 }
51637 {
51638 PyThreadState* __tstate = wxPyBeginAllowThreads();
51639 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51640 wxPyEndAllowThreads(__tstate);
51641 if (PyErr_Occurred()) SWIG_fail;
51642 }
51643 {
51644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51645 }
51646 return resultobj;
51647 fail:
51648 return NULL;
51649 }
51650
51651
51652 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51653 PyObject *resultobj = 0;
51654 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51655 wxSizer *arg2 = (wxSizer *) 0 ;
51656 wxGBPosition *arg3 = 0 ;
51657 bool result;
51658 void *argp1 = 0 ;
51659 int res1 = 0 ;
51660 void *argp2 = 0 ;
51661 int res2 = 0 ;
51662 wxGBPosition temp3 ;
51663
51664 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51666 if (!SWIG_IsOK(res1)) {
51667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51668 }
51669 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51670 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51671 if (!SWIG_IsOK(res2)) {
51672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51673 }
51674 arg2 = reinterpret_cast< wxSizer * >(argp2);
51675 {
51676 arg3 = &temp3;
51677 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51678 }
51679 {
51680 PyThreadState* __tstate = wxPyBeginAllowThreads();
51681 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51682 wxPyEndAllowThreads(__tstate);
51683 if (PyErr_Occurred()) SWIG_fail;
51684 }
51685 {
51686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51687 }
51688 return resultobj;
51689 fail:
51690 return NULL;
51691 }
51692
51693
51694 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51695 PyObject *resultobj = 0;
51696 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51697 size_t arg2 ;
51698 wxGBPosition *arg3 = 0 ;
51699 bool result;
51700 void *argp1 = 0 ;
51701 int res1 = 0 ;
51702 size_t val2 ;
51703 int ecode2 = 0 ;
51704 wxGBPosition temp3 ;
51705
51706 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51708 if (!SWIG_IsOK(res1)) {
51709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51710 }
51711 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51712 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51713 if (!SWIG_IsOK(ecode2)) {
51714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51715 }
51716 arg2 = static_cast< size_t >(val2);
51717 {
51718 arg3 = &temp3;
51719 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51720 }
51721 {
51722 PyThreadState* __tstate = wxPyBeginAllowThreads();
51723 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51724 wxPyEndAllowThreads(__tstate);
51725 if (PyErr_Occurred()) SWIG_fail;
51726 }
51727 {
51728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51729 }
51730 return resultobj;
51731 fail:
51732 return NULL;
51733 }
51734
51735
51736 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51737 int argc;
51738 PyObject *argv[4];
51739
51740 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51741 --argc;
51742 if (argc == 3) {
51743 int _v = 0;
51744 {
51745 void *vptr = 0;
51746 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51747 _v = SWIG_CheckState(res);
51748 }
51749 if (!_v) goto check_1;
51750 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51751 }
51752 check_1:
51753
51754 if (argc == 3) {
51755 int _v = 0;
51756 {
51757 void *vptr = 0;
51758 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51759 _v = SWIG_CheckState(res);
51760 }
51761 if (!_v) goto check_2;
51762 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51763 }
51764 check_2:
51765
51766 if (argc == 3) {
51767 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51768 }
51769
51770 fail:
51771 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51772 return NULL;
51773 }
51774
51775
51776 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51777 PyObject *resultobj = 0;
51778 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51779 wxWindow *arg2 = (wxWindow *) 0 ;
51780 wxGBSpan result;
51781 void *argp1 = 0 ;
51782 int res1 = 0 ;
51783 void *argp2 = 0 ;
51784 int res2 = 0 ;
51785
51786 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51788 if (!SWIG_IsOK(res1)) {
51789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51790 }
51791 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51792 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51793 if (!SWIG_IsOK(res2)) {
51794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51795 }
51796 arg2 = reinterpret_cast< wxWindow * >(argp2);
51797 {
51798 PyThreadState* __tstate = wxPyBeginAllowThreads();
51799 result = (arg1)->GetItemSpan(arg2);
51800 wxPyEndAllowThreads(__tstate);
51801 if (PyErr_Occurred()) SWIG_fail;
51802 }
51803 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51804 return resultobj;
51805 fail:
51806 return NULL;
51807 }
51808
51809
51810 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51811 PyObject *resultobj = 0;
51812 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51813 wxSizer *arg2 = (wxSizer *) 0 ;
51814 wxGBSpan result;
51815 void *argp1 = 0 ;
51816 int res1 = 0 ;
51817 void *argp2 = 0 ;
51818 int res2 = 0 ;
51819
51820 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51822 if (!SWIG_IsOK(res1)) {
51823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51824 }
51825 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51826 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51827 if (!SWIG_IsOK(res2)) {
51828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51829 }
51830 arg2 = reinterpret_cast< wxSizer * >(argp2);
51831 {
51832 PyThreadState* __tstate = wxPyBeginAllowThreads();
51833 result = (arg1)->GetItemSpan(arg2);
51834 wxPyEndAllowThreads(__tstate);
51835 if (PyErr_Occurred()) SWIG_fail;
51836 }
51837 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51838 return resultobj;
51839 fail:
51840 return NULL;
51841 }
51842
51843
51844 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51845 PyObject *resultobj = 0;
51846 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51847 size_t arg2 ;
51848 wxGBSpan result;
51849 void *argp1 = 0 ;
51850 int res1 = 0 ;
51851 size_t val2 ;
51852 int ecode2 = 0 ;
51853
51854 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51856 if (!SWIG_IsOK(res1)) {
51857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51858 }
51859 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51860 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51861 if (!SWIG_IsOK(ecode2)) {
51862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51863 }
51864 arg2 = static_cast< size_t >(val2);
51865 {
51866 PyThreadState* __tstate = wxPyBeginAllowThreads();
51867 result = (arg1)->GetItemSpan(arg2);
51868 wxPyEndAllowThreads(__tstate);
51869 if (PyErr_Occurred()) SWIG_fail;
51870 }
51871 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51872 return resultobj;
51873 fail:
51874 return NULL;
51875 }
51876
51877
51878 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51879 int argc;
51880 PyObject *argv[3];
51881
51882 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51883 --argc;
51884 if (argc == 2) {
51885 int _v = 0;
51886 {
51887 void *vptr = 0;
51888 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51889 _v = SWIG_CheckState(res);
51890 }
51891 if (!_v) goto check_1;
51892 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51893 }
51894 check_1:
51895
51896 if (argc == 2) {
51897 int _v = 0;
51898 {
51899 void *vptr = 0;
51900 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51901 _v = SWIG_CheckState(res);
51902 }
51903 if (!_v) goto check_2;
51904 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51905 }
51906 check_2:
51907
51908 if (argc == 2) {
51909 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51910 }
51911
51912 fail:
51913 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51914 return NULL;
51915 }
51916
51917
51918 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51919 PyObject *resultobj = 0;
51920 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51921 wxWindow *arg2 = (wxWindow *) 0 ;
51922 wxGBSpan *arg3 = 0 ;
51923 bool result;
51924 void *argp1 = 0 ;
51925 int res1 = 0 ;
51926 void *argp2 = 0 ;
51927 int res2 = 0 ;
51928 wxGBSpan temp3 ;
51929
51930 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51932 if (!SWIG_IsOK(res1)) {
51933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51934 }
51935 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51936 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51937 if (!SWIG_IsOK(res2)) {
51938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51939 }
51940 arg2 = reinterpret_cast< wxWindow * >(argp2);
51941 {
51942 arg3 = &temp3;
51943 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51944 }
51945 {
51946 PyThreadState* __tstate = wxPyBeginAllowThreads();
51947 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51948 wxPyEndAllowThreads(__tstate);
51949 if (PyErr_Occurred()) SWIG_fail;
51950 }
51951 {
51952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51953 }
51954 return resultobj;
51955 fail:
51956 return NULL;
51957 }
51958
51959
51960 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51961 PyObject *resultobj = 0;
51962 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51963 wxSizer *arg2 = (wxSizer *) 0 ;
51964 wxGBSpan *arg3 = 0 ;
51965 bool result;
51966 void *argp1 = 0 ;
51967 int res1 = 0 ;
51968 void *argp2 = 0 ;
51969 int res2 = 0 ;
51970 wxGBSpan temp3 ;
51971
51972 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51974 if (!SWIG_IsOK(res1)) {
51975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51976 }
51977 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51978 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51979 if (!SWIG_IsOK(res2)) {
51980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51981 }
51982 arg2 = reinterpret_cast< wxSizer * >(argp2);
51983 {
51984 arg3 = &temp3;
51985 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51986 }
51987 {
51988 PyThreadState* __tstate = wxPyBeginAllowThreads();
51989 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51990 wxPyEndAllowThreads(__tstate);
51991 if (PyErr_Occurred()) SWIG_fail;
51992 }
51993 {
51994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51995 }
51996 return resultobj;
51997 fail:
51998 return NULL;
51999 }
52000
52001
52002 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52003 PyObject *resultobj = 0;
52004 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52005 size_t arg2 ;
52006 wxGBSpan *arg3 = 0 ;
52007 bool result;
52008 void *argp1 = 0 ;
52009 int res1 = 0 ;
52010 size_t val2 ;
52011 int ecode2 = 0 ;
52012 wxGBSpan temp3 ;
52013
52014 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
52015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52016 if (!SWIG_IsOK(res1)) {
52017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52018 }
52019 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52020 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52021 if (!SWIG_IsOK(ecode2)) {
52022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52023 }
52024 arg2 = static_cast< size_t >(val2);
52025 {
52026 arg3 = &temp3;
52027 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52028 }
52029 {
52030 PyThreadState* __tstate = wxPyBeginAllowThreads();
52031 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52032 wxPyEndAllowThreads(__tstate);
52033 if (PyErr_Occurred()) SWIG_fail;
52034 }
52035 {
52036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52037 }
52038 return resultobj;
52039 fail:
52040 return NULL;
52041 }
52042
52043
52044 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52045 int argc;
52046 PyObject *argv[4];
52047
52048 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52049 --argc;
52050 if (argc == 3) {
52051 int _v = 0;
52052 {
52053 void *vptr = 0;
52054 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52055 _v = SWIG_CheckState(res);
52056 }
52057 if (!_v) goto check_1;
52058 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52059 }
52060 check_1:
52061
52062 if (argc == 3) {
52063 int _v = 0;
52064 {
52065 void *vptr = 0;
52066 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52067 _v = SWIG_CheckState(res);
52068 }
52069 if (!_v) goto check_2;
52070 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52071 }
52072 check_2:
52073
52074 if (argc == 3) {
52075 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52076 }
52077
52078 fail:
52079 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52080 return NULL;
52081 }
52082
52083
52084 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52085 PyObject *resultobj = 0;
52086 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52087 wxWindow *arg2 = (wxWindow *) 0 ;
52088 wxGBSizerItem *result = 0 ;
52089 void *argp1 = 0 ;
52090 int res1 = 0 ;
52091 void *argp2 = 0 ;
52092 int res2 = 0 ;
52093
52094 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52096 if (!SWIG_IsOK(res1)) {
52097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52098 }
52099 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52100 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52101 if (!SWIG_IsOK(res2)) {
52102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52103 }
52104 arg2 = reinterpret_cast< wxWindow * >(argp2);
52105 {
52106 PyThreadState* __tstate = wxPyBeginAllowThreads();
52107 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52108 wxPyEndAllowThreads(__tstate);
52109 if (PyErr_Occurred()) SWIG_fail;
52110 }
52111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52112 return resultobj;
52113 fail:
52114 return NULL;
52115 }
52116
52117
52118 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52119 PyObject *resultobj = 0;
52120 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52121 wxSizer *arg2 = (wxSizer *) 0 ;
52122 wxGBSizerItem *result = 0 ;
52123 void *argp1 = 0 ;
52124 int res1 = 0 ;
52125 void *argp2 = 0 ;
52126 int res2 = 0 ;
52127
52128 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52130 if (!SWIG_IsOK(res1)) {
52131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52132 }
52133 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52134 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52135 if (!SWIG_IsOK(res2)) {
52136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52137 }
52138 arg2 = reinterpret_cast< wxSizer * >(argp2);
52139 {
52140 PyThreadState* __tstate = wxPyBeginAllowThreads();
52141 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52142 wxPyEndAllowThreads(__tstate);
52143 if (PyErr_Occurred()) SWIG_fail;
52144 }
52145 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52146 return resultobj;
52147 fail:
52148 return NULL;
52149 }
52150
52151
52152 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52153 int argc;
52154 PyObject *argv[3];
52155
52156 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52157 --argc;
52158 if (argc == 2) {
52159 int _v = 0;
52160 {
52161 void *vptr = 0;
52162 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52163 _v = SWIG_CheckState(res);
52164 }
52165 if (!_v) goto check_1;
52166 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52167 }
52168 check_1:
52169
52170 if (argc == 2) {
52171 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52172 }
52173
52174 fail:
52175 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52176 return NULL;
52177 }
52178
52179
52180 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52181 PyObject *resultobj = 0;
52182 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52183 wxGBPosition *arg2 = 0 ;
52184 wxGBSizerItem *result = 0 ;
52185 void *argp1 = 0 ;
52186 int res1 = 0 ;
52187 wxGBPosition temp2 ;
52188 PyObject * obj0 = 0 ;
52189 PyObject * obj1 = 0 ;
52190 char * kwnames[] = {
52191 (char *) "self",(char *) "pos", NULL
52192 };
52193
52194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52196 if (!SWIG_IsOK(res1)) {
52197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52198 }
52199 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52200 {
52201 arg2 = &temp2;
52202 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52203 }
52204 {
52205 PyThreadState* __tstate = wxPyBeginAllowThreads();
52206 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52207 wxPyEndAllowThreads(__tstate);
52208 if (PyErr_Occurred()) SWIG_fail;
52209 }
52210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52211 return resultobj;
52212 fail:
52213 return NULL;
52214 }
52215
52216
52217 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52218 PyObject *resultobj = 0;
52219 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52220 wxPoint *arg2 = 0 ;
52221 wxGBSizerItem *result = 0 ;
52222 void *argp1 = 0 ;
52223 int res1 = 0 ;
52224 wxPoint temp2 ;
52225 PyObject * obj0 = 0 ;
52226 PyObject * obj1 = 0 ;
52227 char * kwnames[] = {
52228 (char *) "self",(char *) "pt", NULL
52229 };
52230
52231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52233 if (!SWIG_IsOK(res1)) {
52234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52235 }
52236 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52237 {
52238 arg2 = &temp2;
52239 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52240 }
52241 {
52242 PyThreadState* __tstate = wxPyBeginAllowThreads();
52243 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52244 wxPyEndAllowThreads(__tstate);
52245 if (PyErr_Occurred()) SWIG_fail;
52246 }
52247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52248 return resultobj;
52249 fail:
52250 return NULL;
52251 }
52252
52253
52254 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52255 PyObject *resultobj = 0;
52256 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52257 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52258 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52259 bool result;
52260 void *argp1 = 0 ;
52261 int res1 = 0 ;
52262 void *argp2 = 0 ;
52263 int res2 = 0 ;
52264 void *argp3 = 0 ;
52265 int res3 = 0 ;
52266 PyObject * obj0 = 0 ;
52267 PyObject * obj1 = 0 ;
52268 PyObject * obj2 = 0 ;
52269 char * kwnames[] = {
52270 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52271 };
52272
52273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52275 if (!SWIG_IsOK(res1)) {
52276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52277 }
52278 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52279 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52280 if (!SWIG_IsOK(res2)) {
52281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52282 }
52283 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52284 if (obj2) {
52285 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52286 if (!SWIG_IsOK(res3)) {
52287 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52288 }
52289 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52290 }
52291 {
52292 PyThreadState* __tstate = wxPyBeginAllowThreads();
52293 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52294 wxPyEndAllowThreads(__tstate);
52295 if (PyErr_Occurred()) SWIG_fail;
52296 }
52297 {
52298 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52299 }
52300 return resultobj;
52301 fail:
52302 return NULL;
52303 }
52304
52305
52306 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52307 PyObject *resultobj = 0;
52308 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52309 wxGBPosition *arg2 = 0 ;
52310 wxGBSpan *arg3 = 0 ;
52311 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52312 bool result;
52313 void *argp1 = 0 ;
52314 int res1 = 0 ;
52315 wxGBPosition temp2 ;
52316 wxGBSpan temp3 ;
52317 void *argp4 = 0 ;
52318 int res4 = 0 ;
52319 PyObject * obj0 = 0 ;
52320 PyObject * obj1 = 0 ;
52321 PyObject * obj2 = 0 ;
52322 PyObject * obj3 = 0 ;
52323 char * kwnames[] = {
52324 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52325 };
52326
52327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52329 if (!SWIG_IsOK(res1)) {
52330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52331 }
52332 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52333 {
52334 arg2 = &temp2;
52335 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52336 }
52337 {
52338 arg3 = &temp3;
52339 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52340 }
52341 if (obj3) {
52342 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52343 if (!SWIG_IsOK(res4)) {
52344 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52345 }
52346 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52347 }
52348 {
52349 PyThreadState* __tstate = wxPyBeginAllowThreads();
52350 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52351 wxPyEndAllowThreads(__tstate);
52352 if (PyErr_Occurred()) SWIG_fail;
52353 }
52354 {
52355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52356 }
52357 return resultobj;
52358 fail:
52359 return NULL;
52360 }
52361
52362
52363 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52364 PyObject *obj;
52365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52366 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52367 return SWIG_Py_Void();
52368 }
52369
52370 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52371 return SWIG_Python_InitShadowInstance(args);
52372 }
52373
52374 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52375 PyObject *resultobj = 0;
52376 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52377 wxRelationship arg2 ;
52378 wxWindow *arg3 = (wxWindow *) 0 ;
52379 wxEdge arg4 ;
52380 int arg5 = (int) 0 ;
52381 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52382 void *argp1 = 0 ;
52383 int res1 = 0 ;
52384 int val2 ;
52385 int ecode2 = 0 ;
52386 void *argp3 = 0 ;
52387 int res3 = 0 ;
52388 int val4 ;
52389 int ecode4 = 0 ;
52390 int val5 ;
52391 int ecode5 = 0 ;
52392 int val6 ;
52393 int ecode6 = 0 ;
52394 PyObject * obj0 = 0 ;
52395 PyObject * obj1 = 0 ;
52396 PyObject * obj2 = 0 ;
52397 PyObject * obj3 = 0 ;
52398 PyObject * obj4 = 0 ;
52399 PyObject * obj5 = 0 ;
52400 char * kwnames[] = {
52401 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52402 };
52403
52404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52406 if (!SWIG_IsOK(res1)) {
52407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52408 }
52409 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52410 ecode2 = SWIG_AsVal_int(obj1, &val2);
52411 if (!SWIG_IsOK(ecode2)) {
52412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52413 }
52414 arg2 = static_cast< wxRelationship >(val2);
52415 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52416 if (!SWIG_IsOK(res3)) {
52417 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52418 }
52419 arg3 = reinterpret_cast< wxWindow * >(argp3);
52420 ecode4 = SWIG_AsVal_int(obj3, &val4);
52421 if (!SWIG_IsOK(ecode4)) {
52422 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52423 }
52424 arg4 = static_cast< wxEdge >(val4);
52425 if (obj4) {
52426 ecode5 = SWIG_AsVal_int(obj4, &val5);
52427 if (!SWIG_IsOK(ecode5)) {
52428 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52429 }
52430 arg5 = static_cast< int >(val5);
52431 }
52432 if (obj5) {
52433 ecode6 = SWIG_AsVal_int(obj5, &val6);
52434 if (!SWIG_IsOK(ecode6)) {
52435 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52436 }
52437 arg6 = static_cast< int >(val6);
52438 }
52439 {
52440 PyThreadState* __tstate = wxPyBeginAllowThreads();
52441 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52442 wxPyEndAllowThreads(__tstate);
52443 if (PyErr_Occurred()) SWIG_fail;
52444 }
52445 resultobj = SWIG_Py_Void();
52446 return resultobj;
52447 fail:
52448 return NULL;
52449 }
52450
52451
52452 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52453 PyObject *resultobj = 0;
52454 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52455 wxWindow *arg2 = (wxWindow *) 0 ;
52456 int arg3 = (int) 0 ;
52457 void *argp1 = 0 ;
52458 int res1 = 0 ;
52459 void *argp2 = 0 ;
52460 int res2 = 0 ;
52461 int val3 ;
52462 int ecode3 = 0 ;
52463 PyObject * obj0 = 0 ;
52464 PyObject * obj1 = 0 ;
52465 PyObject * obj2 = 0 ;
52466 char * kwnames[] = {
52467 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52468 };
52469
52470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52472 if (!SWIG_IsOK(res1)) {
52473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52474 }
52475 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52476 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52477 if (!SWIG_IsOK(res2)) {
52478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52479 }
52480 arg2 = reinterpret_cast< wxWindow * >(argp2);
52481 if (obj2) {
52482 ecode3 = SWIG_AsVal_int(obj2, &val3);
52483 if (!SWIG_IsOK(ecode3)) {
52484 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52485 }
52486 arg3 = static_cast< int >(val3);
52487 }
52488 {
52489 PyThreadState* __tstate = wxPyBeginAllowThreads();
52490 (arg1)->LeftOf(arg2,arg3);
52491 wxPyEndAllowThreads(__tstate);
52492 if (PyErr_Occurred()) SWIG_fail;
52493 }
52494 resultobj = SWIG_Py_Void();
52495 return resultobj;
52496 fail:
52497 return NULL;
52498 }
52499
52500
52501 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52502 PyObject *resultobj = 0;
52503 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52504 wxWindow *arg2 = (wxWindow *) 0 ;
52505 int arg3 = (int) 0 ;
52506 void *argp1 = 0 ;
52507 int res1 = 0 ;
52508 void *argp2 = 0 ;
52509 int res2 = 0 ;
52510 int val3 ;
52511 int ecode3 = 0 ;
52512 PyObject * obj0 = 0 ;
52513 PyObject * obj1 = 0 ;
52514 PyObject * obj2 = 0 ;
52515 char * kwnames[] = {
52516 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52517 };
52518
52519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52521 if (!SWIG_IsOK(res1)) {
52522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52523 }
52524 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52525 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52526 if (!SWIG_IsOK(res2)) {
52527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52528 }
52529 arg2 = reinterpret_cast< wxWindow * >(argp2);
52530 if (obj2) {
52531 ecode3 = SWIG_AsVal_int(obj2, &val3);
52532 if (!SWIG_IsOK(ecode3)) {
52533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52534 }
52535 arg3 = static_cast< int >(val3);
52536 }
52537 {
52538 PyThreadState* __tstate = wxPyBeginAllowThreads();
52539 (arg1)->RightOf(arg2,arg3);
52540 wxPyEndAllowThreads(__tstate);
52541 if (PyErr_Occurred()) SWIG_fail;
52542 }
52543 resultobj = SWIG_Py_Void();
52544 return resultobj;
52545 fail:
52546 return NULL;
52547 }
52548
52549
52550 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52551 PyObject *resultobj = 0;
52552 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52553 wxWindow *arg2 = (wxWindow *) 0 ;
52554 int arg3 = (int) 0 ;
52555 void *argp1 = 0 ;
52556 int res1 = 0 ;
52557 void *argp2 = 0 ;
52558 int res2 = 0 ;
52559 int val3 ;
52560 int ecode3 = 0 ;
52561 PyObject * obj0 = 0 ;
52562 PyObject * obj1 = 0 ;
52563 PyObject * obj2 = 0 ;
52564 char * kwnames[] = {
52565 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52566 };
52567
52568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52570 if (!SWIG_IsOK(res1)) {
52571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52572 }
52573 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52574 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52575 if (!SWIG_IsOK(res2)) {
52576 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52577 }
52578 arg2 = reinterpret_cast< wxWindow * >(argp2);
52579 if (obj2) {
52580 ecode3 = SWIG_AsVal_int(obj2, &val3);
52581 if (!SWIG_IsOK(ecode3)) {
52582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52583 }
52584 arg3 = static_cast< int >(val3);
52585 }
52586 {
52587 PyThreadState* __tstate = wxPyBeginAllowThreads();
52588 (arg1)->Above(arg2,arg3);
52589 wxPyEndAllowThreads(__tstate);
52590 if (PyErr_Occurred()) SWIG_fail;
52591 }
52592 resultobj = SWIG_Py_Void();
52593 return resultobj;
52594 fail:
52595 return NULL;
52596 }
52597
52598
52599 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52600 PyObject *resultobj = 0;
52601 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52602 wxWindow *arg2 = (wxWindow *) 0 ;
52603 int arg3 = (int) 0 ;
52604 void *argp1 = 0 ;
52605 int res1 = 0 ;
52606 void *argp2 = 0 ;
52607 int res2 = 0 ;
52608 int val3 ;
52609 int ecode3 = 0 ;
52610 PyObject * obj0 = 0 ;
52611 PyObject * obj1 = 0 ;
52612 PyObject * obj2 = 0 ;
52613 char * kwnames[] = {
52614 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52615 };
52616
52617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52619 if (!SWIG_IsOK(res1)) {
52620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52621 }
52622 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52623 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52624 if (!SWIG_IsOK(res2)) {
52625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
52626 }
52627 arg2 = reinterpret_cast< wxWindow * >(argp2);
52628 if (obj2) {
52629 ecode3 = SWIG_AsVal_int(obj2, &val3);
52630 if (!SWIG_IsOK(ecode3)) {
52631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
52632 }
52633 arg3 = static_cast< int >(val3);
52634 }
52635 {
52636 PyThreadState* __tstate = wxPyBeginAllowThreads();
52637 (arg1)->Below(arg2,arg3);
52638 wxPyEndAllowThreads(__tstate);
52639 if (PyErr_Occurred()) SWIG_fail;
52640 }
52641 resultobj = SWIG_Py_Void();
52642 return resultobj;
52643 fail:
52644 return NULL;
52645 }
52646
52647
52648 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52649 PyObject *resultobj = 0;
52650 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52651 wxWindow *arg2 = (wxWindow *) 0 ;
52652 wxEdge arg3 ;
52653 int arg4 = (int) 0 ;
52654 void *argp1 = 0 ;
52655 int res1 = 0 ;
52656 void *argp2 = 0 ;
52657 int res2 = 0 ;
52658 int val3 ;
52659 int ecode3 = 0 ;
52660 int val4 ;
52661 int ecode4 = 0 ;
52662 PyObject * obj0 = 0 ;
52663 PyObject * obj1 = 0 ;
52664 PyObject * obj2 = 0 ;
52665 PyObject * obj3 = 0 ;
52666 char * kwnames[] = {
52667 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52668 };
52669
52670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52672 if (!SWIG_IsOK(res1)) {
52673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52674 }
52675 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52677 if (!SWIG_IsOK(res2)) {
52678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52679 }
52680 arg2 = reinterpret_cast< wxWindow * >(argp2);
52681 ecode3 = SWIG_AsVal_int(obj2, &val3);
52682 if (!SWIG_IsOK(ecode3)) {
52683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52684 }
52685 arg3 = static_cast< wxEdge >(val3);
52686 if (obj3) {
52687 ecode4 = SWIG_AsVal_int(obj3, &val4);
52688 if (!SWIG_IsOK(ecode4)) {
52689 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52690 }
52691 arg4 = static_cast< int >(val4);
52692 }
52693 {
52694 PyThreadState* __tstate = wxPyBeginAllowThreads();
52695 (arg1)->SameAs(arg2,arg3,arg4);
52696 wxPyEndAllowThreads(__tstate);
52697 if (PyErr_Occurred()) SWIG_fail;
52698 }
52699 resultobj = SWIG_Py_Void();
52700 return resultobj;
52701 fail:
52702 return NULL;
52703 }
52704
52705
52706 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52707 PyObject *resultobj = 0;
52708 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52709 wxWindow *arg2 = (wxWindow *) 0 ;
52710 wxEdge arg3 ;
52711 int arg4 ;
52712 void *argp1 = 0 ;
52713 int res1 = 0 ;
52714 void *argp2 = 0 ;
52715 int res2 = 0 ;
52716 int val3 ;
52717 int ecode3 = 0 ;
52718 int val4 ;
52719 int ecode4 = 0 ;
52720 PyObject * obj0 = 0 ;
52721 PyObject * obj1 = 0 ;
52722 PyObject * obj2 = 0 ;
52723 PyObject * obj3 = 0 ;
52724 char * kwnames[] = {
52725 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52726 };
52727
52728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52730 if (!SWIG_IsOK(res1)) {
52731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52732 }
52733 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52734 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52735 if (!SWIG_IsOK(res2)) {
52736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52737 }
52738 arg2 = reinterpret_cast< wxWindow * >(argp2);
52739 ecode3 = SWIG_AsVal_int(obj2, &val3);
52740 if (!SWIG_IsOK(ecode3)) {
52741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52742 }
52743 arg3 = static_cast< wxEdge >(val3);
52744 ecode4 = SWIG_AsVal_int(obj3, &val4);
52745 if (!SWIG_IsOK(ecode4)) {
52746 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52747 }
52748 arg4 = static_cast< int >(val4);
52749 {
52750 PyThreadState* __tstate = wxPyBeginAllowThreads();
52751 (arg1)->PercentOf(arg2,arg3,arg4);
52752 wxPyEndAllowThreads(__tstate);
52753 if (PyErr_Occurred()) SWIG_fail;
52754 }
52755 resultobj = SWIG_Py_Void();
52756 return resultobj;
52757 fail:
52758 return NULL;
52759 }
52760
52761
52762 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52763 PyObject *resultobj = 0;
52764 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52765 int arg2 ;
52766 void *argp1 = 0 ;
52767 int res1 = 0 ;
52768 int val2 ;
52769 int ecode2 = 0 ;
52770 PyObject * obj0 = 0 ;
52771 PyObject * obj1 = 0 ;
52772 char * kwnames[] = {
52773 (char *) "self",(char *) "val", NULL
52774 };
52775
52776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52778 if (!SWIG_IsOK(res1)) {
52779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52780 }
52781 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52782 ecode2 = SWIG_AsVal_int(obj1, &val2);
52783 if (!SWIG_IsOK(ecode2)) {
52784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52785 }
52786 arg2 = static_cast< int >(val2);
52787 {
52788 PyThreadState* __tstate = wxPyBeginAllowThreads();
52789 (arg1)->Absolute(arg2);
52790 wxPyEndAllowThreads(__tstate);
52791 if (PyErr_Occurred()) SWIG_fail;
52792 }
52793 resultobj = SWIG_Py_Void();
52794 return resultobj;
52795 fail:
52796 return NULL;
52797 }
52798
52799
52800 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52801 PyObject *resultobj = 0;
52802 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52803 void *argp1 = 0 ;
52804 int res1 = 0 ;
52805 PyObject *swig_obj[1] ;
52806
52807 if (!args) SWIG_fail;
52808 swig_obj[0] = args;
52809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52810 if (!SWIG_IsOK(res1)) {
52811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52812 }
52813 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52814 {
52815 PyThreadState* __tstate = wxPyBeginAllowThreads();
52816 (arg1)->Unconstrained();
52817 wxPyEndAllowThreads(__tstate);
52818 if (PyErr_Occurred()) SWIG_fail;
52819 }
52820 resultobj = SWIG_Py_Void();
52821 return resultobj;
52822 fail:
52823 return NULL;
52824 }
52825
52826
52827 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52828 PyObject *resultobj = 0;
52829 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52830 void *argp1 = 0 ;
52831 int res1 = 0 ;
52832 PyObject *swig_obj[1] ;
52833
52834 if (!args) SWIG_fail;
52835 swig_obj[0] = args;
52836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52837 if (!SWIG_IsOK(res1)) {
52838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52839 }
52840 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52841 {
52842 PyThreadState* __tstate = wxPyBeginAllowThreads();
52843 (arg1)->AsIs();
52844 wxPyEndAllowThreads(__tstate);
52845 if (PyErr_Occurred()) SWIG_fail;
52846 }
52847 resultobj = SWIG_Py_Void();
52848 return resultobj;
52849 fail:
52850 return NULL;
52851 }
52852
52853
52854 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52855 PyObject *resultobj = 0;
52856 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52857 wxWindow *result = 0 ;
52858 void *argp1 = 0 ;
52859 int res1 = 0 ;
52860 PyObject *swig_obj[1] ;
52861
52862 if (!args) SWIG_fail;
52863 swig_obj[0] = args;
52864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52865 if (!SWIG_IsOK(res1)) {
52866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52867 }
52868 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52869 {
52870 PyThreadState* __tstate = wxPyBeginAllowThreads();
52871 result = (wxWindow *)(arg1)->GetOtherWindow();
52872 wxPyEndAllowThreads(__tstate);
52873 if (PyErr_Occurred()) SWIG_fail;
52874 }
52875 {
52876 resultobj = wxPyMake_wxObject(result, 0);
52877 }
52878 return resultobj;
52879 fail:
52880 return NULL;
52881 }
52882
52883
52884 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52885 PyObject *resultobj = 0;
52886 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52887 wxEdge result;
52888 void *argp1 = 0 ;
52889 int res1 = 0 ;
52890 PyObject *swig_obj[1] ;
52891
52892 if (!args) SWIG_fail;
52893 swig_obj[0] = args;
52894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52895 if (!SWIG_IsOK(res1)) {
52896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52897 }
52898 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52899 {
52900 PyThreadState* __tstate = wxPyBeginAllowThreads();
52901 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52902 wxPyEndAllowThreads(__tstate);
52903 if (PyErr_Occurred()) SWIG_fail;
52904 }
52905 resultobj = SWIG_From_int(static_cast< int >(result));
52906 return resultobj;
52907 fail:
52908 return NULL;
52909 }
52910
52911
52912 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52913 PyObject *resultobj = 0;
52914 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52915 wxEdge arg2 ;
52916 void *argp1 = 0 ;
52917 int res1 = 0 ;
52918 int val2 ;
52919 int ecode2 = 0 ;
52920 PyObject * obj0 = 0 ;
52921 PyObject * obj1 = 0 ;
52922 char * kwnames[] = {
52923 (char *) "self",(char *) "which", NULL
52924 };
52925
52926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52928 if (!SWIG_IsOK(res1)) {
52929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52930 }
52931 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52932 ecode2 = SWIG_AsVal_int(obj1, &val2);
52933 if (!SWIG_IsOK(ecode2)) {
52934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52935 }
52936 arg2 = static_cast< wxEdge >(val2);
52937 {
52938 PyThreadState* __tstate = wxPyBeginAllowThreads();
52939 (arg1)->SetEdge(arg2);
52940 wxPyEndAllowThreads(__tstate);
52941 if (PyErr_Occurred()) SWIG_fail;
52942 }
52943 resultobj = SWIG_Py_Void();
52944 return resultobj;
52945 fail:
52946 return NULL;
52947 }
52948
52949
52950 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52951 PyObject *resultobj = 0;
52952 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52953 int arg2 ;
52954 void *argp1 = 0 ;
52955 int res1 = 0 ;
52956 int val2 ;
52957 int ecode2 = 0 ;
52958 PyObject * obj0 = 0 ;
52959 PyObject * obj1 = 0 ;
52960 char * kwnames[] = {
52961 (char *) "self",(char *) "v", NULL
52962 };
52963
52964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52966 if (!SWIG_IsOK(res1)) {
52967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52968 }
52969 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52970 ecode2 = SWIG_AsVal_int(obj1, &val2);
52971 if (!SWIG_IsOK(ecode2)) {
52972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52973 }
52974 arg2 = static_cast< int >(val2);
52975 {
52976 PyThreadState* __tstate = wxPyBeginAllowThreads();
52977 (arg1)->SetValue(arg2);
52978 wxPyEndAllowThreads(__tstate);
52979 if (PyErr_Occurred()) SWIG_fail;
52980 }
52981 resultobj = SWIG_Py_Void();
52982 return resultobj;
52983 fail:
52984 return NULL;
52985 }
52986
52987
52988 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52989 PyObject *resultobj = 0;
52990 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52991 int result;
52992 void *argp1 = 0 ;
52993 int res1 = 0 ;
52994 PyObject *swig_obj[1] ;
52995
52996 if (!args) SWIG_fail;
52997 swig_obj[0] = args;
52998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52999 if (!SWIG_IsOK(res1)) {
53000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53001 }
53002 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53003 {
53004 PyThreadState* __tstate = wxPyBeginAllowThreads();
53005 result = (int)(arg1)->GetMargin();
53006 wxPyEndAllowThreads(__tstate);
53007 if (PyErr_Occurred()) SWIG_fail;
53008 }
53009 resultobj = SWIG_From_int(static_cast< int >(result));
53010 return resultobj;
53011 fail:
53012 return NULL;
53013 }
53014
53015
53016 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53017 PyObject *resultobj = 0;
53018 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53019 int arg2 ;
53020 void *argp1 = 0 ;
53021 int res1 = 0 ;
53022 int val2 ;
53023 int ecode2 = 0 ;
53024 PyObject * obj0 = 0 ;
53025 PyObject * obj1 = 0 ;
53026 char * kwnames[] = {
53027 (char *) "self",(char *) "m", NULL
53028 };
53029
53030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53032 if (!SWIG_IsOK(res1)) {
53033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53034 }
53035 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53036 ecode2 = SWIG_AsVal_int(obj1, &val2);
53037 if (!SWIG_IsOK(ecode2)) {
53038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53039 }
53040 arg2 = static_cast< int >(val2);
53041 {
53042 PyThreadState* __tstate = wxPyBeginAllowThreads();
53043 (arg1)->SetMargin(arg2);
53044 wxPyEndAllowThreads(__tstate);
53045 if (PyErr_Occurred()) SWIG_fail;
53046 }
53047 resultobj = SWIG_Py_Void();
53048 return resultobj;
53049 fail:
53050 return NULL;
53051 }
53052
53053
53054 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53055 PyObject *resultobj = 0;
53056 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53057 int result;
53058 void *argp1 = 0 ;
53059 int res1 = 0 ;
53060 PyObject *swig_obj[1] ;
53061
53062 if (!args) SWIG_fail;
53063 swig_obj[0] = args;
53064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53065 if (!SWIG_IsOK(res1)) {
53066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53067 }
53068 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53069 {
53070 PyThreadState* __tstate = wxPyBeginAllowThreads();
53071 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53072 wxPyEndAllowThreads(__tstate);
53073 if (PyErr_Occurred()) SWIG_fail;
53074 }
53075 resultobj = SWIG_From_int(static_cast< int >(result));
53076 return resultobj;
53077 fail:
53078 return NULL;
53079 }
53080
53081
53082 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53083 PyObject *resultobj = 0;
53084 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53085 int result;
53086 void *argp1 = 0 ;
53087 int res1 = 0 ;
53088 PyObject *swig_obj[1] ;
53089
53090 if (!args) SWIG_fail;
53091 swig_obj[0] = args;
53092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53093 if (!SWIG_IsOK(res1)) {
53094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53095 }
53096 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53097 {
53098 PyThreadState* __tstate = wxPyBeginAllowThreads();
53099 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53100 wxPyEndAllowThreads(__tstate);
53101 if (PyErr_Occurred()) SWIG_fail;
53102 }
53103 resultobj = SWIG_From_int(static_cast< int >(result));
53104 return resultobj;
53105 fail:
53106 return NULL;
53107 }
53108
53109
53110 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53111 PyObject *resultobj = 0;
53112 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53113 int result;
53114 void *argp1 = 0 ;
53115 int res1 = 0 ;
53116 PyObject *swig_obj[1] ;
53117
53118 if (!args) SWIG_fail;
53119 swig_obj[0] = args;
53120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53121 if (!SWIG_IsOK(res1)) {
53122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53123 }
53124 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53125 {
53126 PyThreadState* __tstate = wxPyBeginAllowThreads();
53127 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53128 wxPyEndAllowThreads(__tstate);
53129 if (PyErr_Occurred()) SWIG_fail;
53130 }
53131 resultobj = SWIG_From_int(static_cast< int >(result));
53132 return resultobj;
53133 fail:
53134 return NULL;
53135 }
53136
53137
53138 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53139 PyObject *resultobj = 0;
53140 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53141 bool result;
53142 void *argp1 = 0 ;
53143 int res1 = 0 ;
53144 PyObject *swig_obj[1] ;
53145
53146 if (!args) SWIG_fail;
53147 swig_obj[0] = args;
53148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53149 if (!SWIG_IsOK(res1)) {
53150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53151 }
53152 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53153 {
53154 PyThreadState* __tstate = wxPyBeginAllowThreads();
53155 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53156 wxPyEndAllowThreads(__tstate);
53157 if (PyErr_Occurred()) SWIG_fail;
53158 }
53159 {
53160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53161 }
53162 return resultobj;
53163 fail:
53164 return NULL;
53165 }
53166
53167
53168 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53169 PyObject *resultobj = 0;
53170 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53171 bool arg2 ;
53172 void *argp1 = 0 ;
53173 int res1 = 0 ;
53174 bool val2 ;
53175 int ecode2 = 0 ;
53176 PyObject * obj0 = 0 ;
53177 PyObject * obj1 = 0 ;
53178 char * kwnames[] = {
53179 (char *) "self",(char *) "d", NULL
53180 };
53181
53182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53184 if (!SWIG_IsOK(res1)) {
53185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53186 }
53187 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53188 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53189 if (!SWIG_IsOK(ecode2)) {
53190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53191 }
53192 arg2 = static_cast< bool >(val2);
53193 {
53194 PyThreadState* __tstate = wxPyBeginAllowThreads();
53195 (arg1)->SetDone(arg2);
53196 wxPyEndAllowThreads(__tstate);
53197 if (PyErr_Occurred()) SWIG_fail;
53198 }
53199 resultobj = SWIG_Py_Void();
53200 return resultobj;
53201 fail:
53202 return NULL;
53203 }
53204
53205
53206 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53207 PyObject *resultobj = 0;
53208 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53209 wxRelationship result;
53210 void *argp1 = 0 ;
53211 int res1 = 0 ;
53212 PyObject *swig_obj[1] ;
53213
53214 if (!args) SWIG_fail;
53215 swig_obj[0] = args;
53216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53217 if (!SWIG_IsOK(res1)) {
53218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53219 }
53220 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53221 {
53222 PyThreadState* __tstate = wxPyBeginAllowThreads();
53223 result = (wxRelationship)(arg1)->GetRelationship();
53224 wxPyEndAllowThreads(__tstate);
53225 if (PyErr_Occurred()) SWIG_fail;
53226 }
53227 resultobj = SWIG_From_int(static_cast< int >(result));
53228 return resultobj;
53229 fail:
53230 return NULL;
53231 }
53232
53233
53234 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53235 PyObject *resultobj = 0;
53236 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53237 wxRelationship arg2 ;
53238 void *argp1 = 0 ;
53239 int res1 = 0 ;
53240 int val2 ;
53241 int ecode2 = 0 ;
53242 PyObject * obj0 = 0 ;
53243 PyObject * obj1 = 0 ;
53244 char * kwnames[] = {
53245 (char *) "self",(char *) "r", NULL
53246 };
53247
53248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53250 if (!SWIG_IsOK(res1)) {
53251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53252 }
53253 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53254 ecode2 = SWIG_AsVal_int(obj1, &val2);
53255 if (!SWIG_IsOK(ecode2)) {
53256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53257 }
53258 arg2 = static_cast< wxRelationship >(val2);
53259 {
53260 PyThreadState* __tstate = wxPyBeginAllowThreads();
53261 (arg1)->SetRelationship(arg2);
53262 wxPyEndAllowThreads(__tstate);
53263 if (PyErr_Occurred()) SWIG_fail;
53264 }
53265 resultobj = SWIG_Py_Void();
53266 return resultobj;
53267 fail:
53268 return NULL;
53269 }
53270
53271
53272 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53273 PyObject *resultobj = 0;
53274 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53275 wxWindow *arg2 = (wxWindow *) 0 ;
53276 bool result;
53277 void *argp1 = 0 ;
53278 int res1 = 0 ;
53279 void *argp2 = 0 ;
53280 int res2 = 0 ;
53281 PyObject * obj0 = 0 ;
53282 PyObject * obj1 = 0 ;
53283 char * kwnames[] = {
53284 (char *) "self",(char *) "otherW", NULL
53285 };
53286
53287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53289 if (!SWIG_IsOK(res1)) {
53290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53291 }
53292 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53294 if (!SWIG_IsOK(res2)) {
53295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53296 }
53297 arg2 = reinterpret_cast< wxWindow * >(argp2);
53298 {
53299 PyThreadState* __tstate = wxPyBeginAllowThreads();
53300 result = (bool)(arg1)->ResetIfWin(arg2);
53301 wxPyEndAllowThreads(__tstate);
53302 if (PyErr_Occurred()) SWIG_fail;
53303 }
53304 {
53305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53306 }
53307 return resultobj;
53308 fail:
53309 return NULL;
53310 }
53311
53312
53313 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53314 PyObject *resultobj = 0;
53315 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53316 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53317 wxWindow *arg3 = (wxWindow *) 0 ;
53318 bool result;
53319 void *argp1 = 0 ;
53320 int res1 = 0 ;
53321 void *argp2 = 0 ;
53322 int res2 = 0 ;
53323 void *argp3 = 0 ;
53324 int res3 = 0 ;
53325 PyObject * obj0 = 0 ;
53326 PyObject * obj1 = 0 ;
53327 PyObject * obj2 = 0 ;
53328 char * kwnames[] = {
53329 (char *) "self",(char *) "constraints",(char *) "win", NULL
53330 };
53331
53332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53334 if (!SWIG_IsOK(res1)) {
53335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53336 }
53337 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53339 if (!SWIG_IsOK(res2)) {
53340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53341 }
53342 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53343 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53344 if (!SWIG_IsOK(res3)) {
53345 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53346 }
53347 arg3 = reinterpret_cast< wxWindow * >(argp3);
53348 {
53349 PyThreadState* __tstate = wxPyBeginAllowThreads();
53350 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53351 wxPyEndAllowThreads(__tstate);
53352 if (PyErr_Occurred()) SWIG_fail;
53353 }
53354 {
53355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53356 }
53357 return resultobj;
53358 fail:
53359 return NULL;
53360 }
53361
53362
53363 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53364 PyObject *resultobj = 0;
53365 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53366 wxEdge arg2 ;
53367 wxWindow *arg3 = (wxWindow *) 0 ;
53368 wxWindow *arg4 = (wxWindow *) 0 ;
53369 int result;
53370 void *argp1 = 0 ;
53371 int res1 = 0 ;
53372 int val2 ;
53373 int ecode2 = 0 ;
53374 void *argp3 = 0 ;
53375 int res3 = 0 ;
53376 void *argp4 = 0 ;
53377 int res4 = 0 ;
53378 PyObject * obj0 = 0 ;
53379 PyObject * obj1 = 0 ;
53380 PyObject * obj2 = 0 ;
53381 PyObject * obj3 = 0 ;
53382 char * kwnames[] = {
53383 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53384 };
53385
53386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53388 if (!SWIG_IsOK(res1)) {
53389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53390 }
53391 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53392 ecode2 = SWIG_AsVal_int(obj1, &val2);
53393 if (!SWIG_IsOK(ecode2)) {
53394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53395 }
53396 arg2 = static_cast< wxEdge >(val2);
53397 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53398 if (!SWIG_IsOK(res3)) {
53399 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53400 }
53401 arg3 = reinterpret_cast< wxWindow * >(argp3);
53402 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53403 if (!SWIG_IsOK(res4)) {
53404 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53405 }
53406 arg4 = reinterpret_cast< wxWindow * >(argp4);
53407 {
53408 PyThreadState* __tstate = wxPyBeginAllowThreads();
53409 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53410 wxPyEndAllowThreads(__tstate);
53411 if (PyErr_Occurred()) SWIG_fail;
53412 }
53413 resultobj = SWIG_From_int(static_cast< int >(result));
53414 return resultobj;
53415 fail:
53416 return NULL;
53417 }
53418
53419
53420 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53421 PyObject *obj;
53422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53423 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53424 return SWIG_Py_Void();
53425 }
53426
53427 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53428 PyObject *resultobj = 0;
53429 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53430 wxIndividualLayoutConstraint *result = 0 ;
53431 void *argp1 = 0 ;
53432 int res1 = 0 ;
53433 PyObject *swig_obj[1] ;
53434
53435 if (!args) SWIG_fail;
53436 swig_obj[0] = args;
53437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53438 if (!SWIG_IsOK(res1)) {
53439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53440 }
53441 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53442 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53444 return resultobj;
53445 fail:
53446 return NULL;
53447 }
53448
53449
53450 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53451 PyObject *resultobj = 0;
53452 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53453 wxIndividualLayoutConstraint *result = 0 ;
53454 void *argp1 = 0 ;
53455 int res1 = 0 ;
53456 PyObject *swig_obj[1] ;
53457
53458 if (!args) SWIG_fail;
53459 swig_obj[0] = args;
53460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53461 if (!SWIG_IsOK(res1)) {
53462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53463 }
53464 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53465 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53467 return resultobj;
53468 fail:
53469 return NULL;
53470 }
53471
53472
53473 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53474 PyObject *resultobj = 0;
53475 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53476 wxIndividualLayoutConstraint *result = 0 ;
53477 void *argp1 = 0 ;
53478 int res1 = 0 ;
53479 PyObject *swig_obj[1] ;
53480
53481 if (!args) SWIG_fail;
53482 swig_obj[0] = args;
53483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53484 if (!SWIG_IsOK(res1)) {
53485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53486 }
53487 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53488 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53490 return resultobj;
53491 fail:
53492 return NULL;
53493 }
53494
53495
53496 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53497 PyObject *resultobj = 0;
53498 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53499 wxIndividualLayoutConstraint *result = 0 ;
53500 void *argp1 = 0 ;
53501 int res1 = 0 ;
53502 PyObject *swig_obj[1] ;
53503
53504 if (!args) SWIG_fail;
53505 swig_obj[0] = args;
53506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53507 if (!SWIG_IsOK(res1)) {
53508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53509 }
53510 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53511 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53513 return resultobj;
53514 fail:
53515 return NULL;
53516 }
53517
53518
53519 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53520 PyObject *resultobj = 0;
53521 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53522 wxIndividualLayoutConstraint *result = 0 ;
53523 void *argp1 = 0 ;
53524 int res1 = 0 ;
53525 PyObject *swig_obj[1] ;
53526
53527 if (!args) SWIG_fail;
53528 swig_obj[0] = args;
53529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53530 if (!SWIG_IsOK(res1)) {
53531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53532 }
53533 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53534 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53535 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53536 return resultobj;
53537 fail:
53538 return NULL;
53539 }
53540
53541
53542 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53543 PyObject *resultobj = 0;
53544 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53545 wxIndividualLayoutConstraint *result = 0 ;
53546 void *argp1 = 0 ;
53547 int res1 = 0 ;
53548 PyObject *swig_obj[1] ;
53549
53550 if (!args) SWIG_fail;
53551 swig_obj[0] = args;
53552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53553 if (!SWIG_IsOK(res1)) {
53554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53555 }
53556 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53557 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53559 return resultobj;
53560 fail:
53561 return NULL;
53562 }
53563
53564
53565 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53566 PyObject *resultobj = 0;
53567 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53568 wxIndividualLayoutConstraint *result = 0 ;
53569 void *argp1 = 0 ;
53570 int res1 = 0 ;
53571 PyObject *swig_obj[1] ;
53572
53573 if (!args) SWIG_fail;
53574 swig_obj[0] = args;
53575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53576 if (!SWIG_IsOK(res1)) {
53577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53578 }
53579 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53580 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53582 return resultobj;
53583 fail:
53584 return NULL;
53585 }
53586
53587
53588 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53589 PyObject *resultobj = 0;
53590 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53591 wxIndividualLayoutConstraint *result = 0 ;
53592 void *argp1 = 0 ;
53593 int res1 = 0 ;
53594 PyObject *swig_obj[1] ;
53595
53596 if (!args) SWIG_fail;
53597 swig_obj[0] = args;
53598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53599 if (!SWIG_IsOK(res1)) {
53600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53601 }
53602 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53603 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
53604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53605 return resultobj;
53606 fail:
53607 return NULL;
53608 }
53609
53610
53611 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53612 PyObject *resultobj = 0;
53613 wxLayoutConstraints *result = 0 ;
53614
53615 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
53616 {
53617 PyThreadState* __tstate = wxPyBeginAllowThreads();
53618 result = (wxLayoutConstraints *)new wxLayoutConstraints();
53619 wxPyEndAllowThreads(__tstate);
53620 if (PyErr_Occurred()) SWIG_fail;
53621 }
53622 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
53623 return resultobj;
53624 fail:
53625 return NULL;
53626 }
53627
53628
53629 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53630 PyObject *resultobj = 0;
53631 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53632 void *argp1 = 0 ;
53633 int res1 = 0 ;
53634 PyObject *swig_obj[1] ;
53635
53636 if (!args) SWIG_fail;
53637 swig_obj[0] = args;
53638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
53639 if (!SWIG_IsOK(res1)) {
53640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53641 }
53642 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53643 {
53644 PyThreadState* __tstate = wxPyBeginAllowThreads();
53645 delete arg1;
53646
53647 wxPyEndAllowThreads(__tstate);
53648 if (PyErr_Occurred()) SWIG_fail;
53649 }
53650 resultobj = SWIG_Py_Void();
53651 return resultobj;
53652 fail:
53653 return NULL;
53654 }
53655
53656
53657 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53658 PyObject *resultobj = 0;
53659 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53660 wxWindow *arg2 = (wxWindow *) 0 ;
53661 int *arg3 = (int *) 0 ;
53662 bool result;
53663 void *argp1 = 0 ;
53664 int res1 = 0 ;
53665 void *argp2 = 0 ;
53666 int res2 = 0 ;
53667 int temp3 ;
53668 int res3 = SWIG_TMPOBJ ;
53669 PyObject * obj0 = 0 ;
53670 PyObject * obj1 = 0 ;
53671 char * kwnames[] = {
53672 (char *) "self",(char *) "win", NULL
53673 };
53674
53675 arg3 = &temp3;
53676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53678 if (!SWIG_IsOK(res1)) {
53679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53680 }
53681 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53682 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53683 if (!SWIG_IsOK(res2)) {
53684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53685 }
53686 arg2 = reinterpret_cast< wxWindow * >(argp2);
53687 {
53688 PyThreadState* __tstate = wxPyBeginAllowThreads();
53689 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53690 wxPyEndAllowThreads(__tstate);
53691 if (PyErr_Occurred()) SWIG_fail;
53692 }
53693 {
53694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53695 }
53696 if (SWIG_IsTmpObj(res3)) {
53697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53698 } else {
53699 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53701 }
53702 return resultobj;
53703 fail:
53704 return NULL;
53705 }
53706
53707
53708 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53709 PyObject *resultobj = 0;
53710 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53711 bool result;
53712 void *argp1 = 0 ;
53713 int res1 = 0 ;
53714 PyObject *swig_obj[1] ;
53715
53716 if (!args) SWIG_fail;
53717 swig_obj[0] = args;
53718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53719 if (!SWIG_IsOK(res1)) {
53720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53721 }
53722 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53723 {
53724 PyThreadState* __tstate = wxPyBeginAllowThreads();
53725 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53726 wxPyEndAllowThreads(__tstate);
53727 if (PyErr_Occurred()) SWIG_fail;
53728 }
53729 {
53730 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53731 }
53732 return resultobj;
53733 fail:
53734 return NULL;
53735 }
53736
53737
53738 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53739 PyObject *obj;
53740 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53741 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53742 return SWIG_Py_Void();
53743 }
53744
53745 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53746 return SWIG_Python_InitShadowInstance(args);
53747 }
53748
53749 static PyMethodDef SwigMethods[] = {
53750 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53751 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53752 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53753 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53754 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53755 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53756 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53757 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53758 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53760 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53771 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53772 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53773 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53775 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53776 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53777 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53778 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53779 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53780 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53781 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53783 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53789 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53790 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53791 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53792 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53793 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53794 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53795 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53797 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53803 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53805 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53806 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53807 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53812 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53813 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53815 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53817 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53819 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53821 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53823 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53825 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53826 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53828 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53830 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53831 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53832 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53833 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53837 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53853 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53854 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53855 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53856 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53857 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53858 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53859 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53860 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53862 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53863 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53864 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53869 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53870 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53871 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53872 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53879 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53880 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53886 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53887 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53888 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53889 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53891 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53892 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53893 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53895 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53896 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53897 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53898 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53903 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53904 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53905 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53906 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53907 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53908 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53911 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53912 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53913 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53915 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53916 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53918 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53919 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
53920 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53921 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53922 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53923 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53924 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53925 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53926 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53927 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53928 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53929 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53932 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53934 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53940 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53941 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53942 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53943 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53945 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53948 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53951 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53954 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53955 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53956 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53959 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53960 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53961 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53965 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53966 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53967 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53971 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53976 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53977 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53978 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53979 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53980 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53981 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53982 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53984 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53989 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53990 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53992 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53993 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53994 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
54000 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
54001 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
54002 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
54003 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
54004 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
54005 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
54006 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
54007 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
54008 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
54009 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
54010 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
54012 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
54013 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
54014 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
54015 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54016 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54017 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54018 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54019 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54021 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54030 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54042 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54043 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54048 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54052 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54058 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54059 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54060 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54061 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54064 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54066 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54068 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54070 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54072 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54075 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54076 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54077 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54078 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54080 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54081 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54095 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54097 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54098 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54100 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54104 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54105 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54106 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54107 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54108 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54109 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54110 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54111 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54112 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54113 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54114 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54115 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54116 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54117 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54118 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54119 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54120 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54121 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54122 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54123 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54124 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54125 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54126 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54127 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54128 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54129 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54130 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54131 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54132 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54133 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54134 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54135 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54136 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54137 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54138 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54139 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54141 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54142 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54143 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54144 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54147 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54149 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54151 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54155 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54156 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54157 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54158 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54160 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54161 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54163 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54164 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54165 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54167 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54169 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54170 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54171 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54172 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54173 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54174 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54176 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54177 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54178 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54180 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54181 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54182 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54183 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54184 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54185 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54186 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54187 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54188 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54190 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54192 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54193 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54195 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54196 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54197 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54199 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54200 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54201 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54202 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54203 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54205 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54206 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54209 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54210 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54211 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54212 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54213 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54216 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54217 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54218 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54219 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54225 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54226 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54227 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54228 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54229 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54230 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54231 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54232 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54233 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54234 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54235 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54236 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54237 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54238 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54239 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54240 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54241 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54242 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54243 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54244 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54245 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54246 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54247 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54248 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54249 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54250 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54251 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54252 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54253 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54254 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54255 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54256 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54257 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54258 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54259 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54260 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54261 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54262 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54263 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54264 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54265 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54266 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54267 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54268 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54269 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54270 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54271 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54272 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54273 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54274 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54275 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54276 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54277 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54278 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54279 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54280 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54281 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54282 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54283 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54284 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54285 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54286 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54287 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54288 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54289 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54290 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54291 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54292 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54293 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54294 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54295 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54296 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54297 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54298 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54299 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54300 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54301 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54302 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54303 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54304 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54305 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54306 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54307 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54308 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54309 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54310 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54311 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54312 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54313 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54314 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54315 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54316 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54317 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54318 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54319 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54320 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54321 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54322 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54323 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54324 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54325 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54326 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54327 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54328 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54329 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54330 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54331 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54332 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54333 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54334 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54335 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54336 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54337 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54338 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54339 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54341 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54342 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54344 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54345 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54346 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54347 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54348 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54349 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54351 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54352 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54353 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54354 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54355 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54356 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54358 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54359 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54360 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54361 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54363 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54364 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54365 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54367 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54368 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54369 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54370 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54371 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54372 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54374 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54375 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54376 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54377 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54378 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54379 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54380 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54381 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54382 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54383 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54385 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54386 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54387 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54389 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54390 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54391 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54392 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54393 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54394 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54395 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54396 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54398 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54399 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54400 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54401 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54402 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54403 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54404 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54405 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54406 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54407 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54408 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54409 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54410 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54411 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54412 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54413 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54415 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54417 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54418 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54419 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54420 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54421 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54422 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54423 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54424 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54425 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54426 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54427 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54429 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54430 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54431 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54432 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54433 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54434 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54435 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54436 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54437 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54440 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54441 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54442 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54443 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54445 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54446 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54447 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54448 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54449 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54451 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54453 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54455 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54456 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54457 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54458 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54459 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54461 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54462 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54463 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54465 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54466 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54467 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54469 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54471 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54472 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54473 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54474 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54475 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54477 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54479 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54480 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54482 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54483 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54484 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54485 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54487 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54488 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54489 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54490 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54491 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54492 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54493 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54494 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54495 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54497 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54498 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54499 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54500 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54501 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54502 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54503 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54504 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54505 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54506 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54508 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54509 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54510 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54511 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54512 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54513 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54514 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54515 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54516 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54517 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54518 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54519 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54520 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54521 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54522 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54523 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54524 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54525 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54526 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54527 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54528 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54529 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54530 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54531 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54532 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54533 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54534 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54535 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54536 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54537 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54538 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54539 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54540 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54541 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54542 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54543 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54544 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54545 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
54546 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54547 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54548 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54549 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54550 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54551 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54552 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54553 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54554 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54555 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54556 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54557 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54558 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54559 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54560 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54561 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54562 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54563 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54564 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54565 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54566 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54567 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54568 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54569 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54570 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54571 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54572 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54573 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54574 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54575 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54576 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54578 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54579 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54580 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54581 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54582 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54584 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54585 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54587 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54588 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54589 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54590 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54591 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
54592 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
54593 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
54594 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
54595 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
54596 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
54597 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
54598 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
54599 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
54600 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
54601 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
54603 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
54605 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
54606 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
54607 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
54608 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
54610 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
54612 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
54614 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54615 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
54616 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
54617 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54619 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
54620 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54621 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54622 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54623 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
54624 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54625 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54626 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
54627 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
54630 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
54631 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
54635 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
54636 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
54637 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
54638 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
54639 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
54640 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
54641 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
54642 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
54643 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
54644 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
54645 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
54646 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
54647 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
54648 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
54649 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
54650 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
54651 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
54652 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
54653 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
54654 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
54655 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
54656 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54658 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54659 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54660 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
54661 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
54662 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54663 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
54664 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
54665 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
54666 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
54667 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
54668 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
54669 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54670 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
54671 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
54672 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
54673 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54674 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
54675 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54676 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54677 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54678 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54679 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
54680 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54681 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54682 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54683 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54684 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54685 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54686 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54687 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54688 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54689 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54690 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54691 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54692 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54693 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54694 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54695 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54696 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54697 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54698 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54699 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54700 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54701 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54702 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54703 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54704 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54705 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54706 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54707 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54708 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54709 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54710 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54711 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54712 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54713 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54714 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54715 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54716 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54717 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54718 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54719 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54720 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54721 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54722 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54723 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54724 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54725 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54726 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54727 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54728 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54729 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54730 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54731 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54732 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54733 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54734 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54736 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54737 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54738 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
54739 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54740 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54741 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54742 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54743 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54744 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54745 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54746 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54747 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54748 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54749 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54750 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54751 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54752 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54753 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54754 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54755 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54756 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54757 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54758 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54759 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54760 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54761 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54762 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54763 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54764 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54765 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54766 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54767 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54768 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54769 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54770 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54771 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54773 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54776 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54777 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54778 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54779 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54780 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54781 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54782 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54783 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54784 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
54785 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54786 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54787 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54788 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54789 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54790 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54791 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54792 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54793 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54794 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54795 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54796 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54797 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54798 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54799 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54800 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54802 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54803 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54804 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54805 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54806 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54807 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54808 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54809 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54810 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54811 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54812 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54813 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54814 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54815 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54816 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54817 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54818 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54819 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54820 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54821 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54822 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54823 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54824 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54825 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54826 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54827 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54828 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54829 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54830 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54831 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54832 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54833 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54834 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54835 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54836 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54837 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54838 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54839 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54840 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54841 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54842 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54843 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54844 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54845 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54846 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54847 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54848 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54849 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54850 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54852 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54853 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54854 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54855 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54856 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54857 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54859 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54860 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54861 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54862 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54863 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54864 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54865 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54866 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54867 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54868 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54869 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54870 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54871 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54872 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54873 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54874 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54875 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54876 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54877 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54878 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54879 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54880 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54881 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54882 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54883 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54884 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54885 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54887 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54888 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54889 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54891 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54892 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54893 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54894 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54896 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54897 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54898 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54899 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54900 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54901 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54902 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54903 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54904 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54905 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54906 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54907 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54908 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54909 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54910 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54912 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54913 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54914 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54916 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54917 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54918 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54919 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54921 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54922 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54923 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54924 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54925 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54926 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54927 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54928 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54929 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54930 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54931 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54932 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54934 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54935 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54936 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54937 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54938 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54939 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54940 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54941 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54942 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54943 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54944 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54945 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54946 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54947 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54948 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54949 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54950 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54951 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54952 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54953 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54954 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54955 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54956 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54957 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54958 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54959 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54960 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54961 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54962 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54963 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54964 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54965 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54966 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54967 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54968 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54969 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54970 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54972 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54973 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54974 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54976 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54977 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54978 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54979 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54980 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54981 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54982 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54983 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54985 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54987 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54988 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54989 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54990 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54991 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54992 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54993 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54994 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54996 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54997 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54998 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54999 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
55000 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
55001 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55002 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
55003 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
55005 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
55006 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
55007 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
55008 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
55009 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
55010 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55011 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55012 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55013 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
55014 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
55015 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
55016 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55017 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55018 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55019 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55020 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55023 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55024 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55025 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55026 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55027 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55028 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55029 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55030 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55031 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55033 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55035 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55036 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55037 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55038 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55039 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55040 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55042 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55043 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55044 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55045 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55046 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55047 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55048 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55049 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55050 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55051 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55052 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55053 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55054 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55055 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55056 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55057 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55058 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55060 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55062 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55063 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55064 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55065 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55066 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55067 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55068 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55069 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55070 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55071 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55072 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55073 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55074 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55075 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55076 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55077 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55078 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55079 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55080 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55081 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55082 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55084 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55085 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55086 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55087 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55088 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55089 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55090 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55091 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55092 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55093 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55094 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55095 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55096 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55097 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55099 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55100 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55101 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55102 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55103 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55104 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55105 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55106 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55107 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55108 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55110 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55111 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55112 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55113 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55114 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55115 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55116 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55117 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55118 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55119 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55120 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55121 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55122 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55123 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55124 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55126 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55127 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55128 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55129 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55130 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55131 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55132 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55133 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55134 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55136 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55137 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55138 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55139 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55140 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55141 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55142 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55143 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55144 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55145 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55146 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55147 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55148 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55149 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55150 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55151 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55152 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55153 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55154 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55155 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55156 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55157 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55158 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55159 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55160 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55161 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55162 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55164 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55165 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55166 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55167 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55168 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55170 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55171 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55172 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55173 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55174 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55175 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55176 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55177 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55179 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55181 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55182 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55183 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55184 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55185 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55186 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55189 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55190 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55191 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55192 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55193 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55194 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55195 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55196 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55197 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55198 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55199 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55200 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55201 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55202 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55203 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55204 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55205 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55206 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55207 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55208 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55209 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55210 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55211 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55212 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55213 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55214 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55215 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55216 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55217 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55218 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55219 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55220 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55221 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55222 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55223 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55224 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55225 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55226 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55227 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55228 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55229 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55230 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55231 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55232 { NULL, NULL, 0, NULL }
55233 };
55234
55235
55236 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55237
55238 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55239 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55240 }
55241 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55242 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55243 }
55244 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55245 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55246 }
55247 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55248 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55249 }
55250 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55251 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55252 }
55253 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55254 return (void *)((wxSizer *) ((wxGridSizer *) x));
55255 }
55256 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55257 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55258 }
55259 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55260 return (void *)((wxSizer *) ((wxPySizer *) x));
55261 }
55262 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55263 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55264 }
55265 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55266 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55267 }
55268 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55269 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55270 }
55271 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55272 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55273 }
55274 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55275 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55276 }
55277 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55278 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55279 }
55280 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55281 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55282 }
55283 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55284 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55285 }
55286 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55287 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55288 }
55289 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55290 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55291 }
55292 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55293 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55294 }
55295 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55296 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55297 }
55298 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55299 return (void *)((wxEvent *) ((wxPyEvent *) x));
55300 }
55301 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55302 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55303 }
55304 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55305 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55306 }
55307 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55308 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55309 }
55310 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55311 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55312 }
55313 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55314 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55315 }
55316 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55317 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55318 }
55319 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55320 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55321 }
55322 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55323 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55324 }
55325 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55326 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55327 }
55328 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55329 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55330 }
55331 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55332 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55333 }
55334 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55335 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55336 }
55337 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55338 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55339 }
55340 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55341 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55342 }
55343 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55344 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55345 }
55346 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55347 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55348 }
55349 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55350 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55351 }
55352 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55353 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55354 }
55355 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55356 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55357 }
55358 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55359 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55360 }
55361 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55362 return (void *)((wxEvent *) ((wxShowEvent *) x));
55363 }
55364 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55365 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55366 }
55367 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55368 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55369 }
55370 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55371 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55372 }
55373 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55374 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55375 }
55376 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55377 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55378 }
55379 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55380 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55381 }
55382 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55383 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55384 }
55385 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55386 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55387 }
55388 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55389 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55390 }
55391 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55392 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55393 }
55394 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55395 return (void *)((wxControl *) ((wxControlWithItems *) x));
55396 }
55397 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55398 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55399 }
55400 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55401 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55402 }
55403 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55404 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55405 }
55406 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55407 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55408 }
55409 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55410 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55411 }
55412 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55413 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55414 }
55415 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55416 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55417 }
55418 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55419 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55420 }
55421 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55422 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55423 }
55424 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55425 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55426 }
55427 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55428 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55429 }
55430 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55431 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55432 }
55433 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55434 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55435 }
55436 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55437 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55438 }
55439 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55440 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55441 }
55442 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55443 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55444 }
55445 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55446 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55447 }
55448 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55449 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55450 }
55451 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55452 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55453 }
55454 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55455 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55456 }
55457 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55458 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55459 }
55460 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55461 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55462 }
55463 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55464 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55465 }
55466 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55467 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55468 }
55469 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55470 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55471 }
55472 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55473 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55474 }
55475 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55476 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55477 }
55478 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55479 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55480 }
55481 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55482 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55483 }
55484 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55485 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55486 }
55487 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55488 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55489 }
55490 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55491 return (void *)((wxObject *) ((wxSizerItem *) x));
55492 }
55493 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55494 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55495 }
55496 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55497 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55498 }
55499 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55500 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55501 }
55502 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55503 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55504 }
55505 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55506 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55507 }
55508 static void *_p_wxSizerTo_p_wxObject(void *x) {
55509 return (void *)((wxObject *) ((wxSizer *) x));
55510 }
55511 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55512 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55513 }
55514 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55515 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55516 }
55517 static void *_p_wxEventTo_p_wxObject(void *x) {
55518 return (void *)((wxObject *) ((wxEvent *) x));
55519 }
55520 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55521 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55522 }
55523 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55524 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55525 }
55526 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55527 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55528 }
55529 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55530 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55531 }
55532 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55533 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55534 }
55535 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55536 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55537 }
55538 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55539 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55540 }
55541 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55542 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55543 }
55544 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55545 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55546 }
55547 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55548 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55549 }
55550 static void *_p_wxControlTo_p_wxObject(void *x) {
55551 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55552 }
55553 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55554 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55555 }
55556 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55557 return (void *)((wxObject *) ((wxFSFile *) x));
55558 }
55559 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55560 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55561 }
55562 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55563 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55564 }
55565 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55566 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55567 }
55568 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55569 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55570 }
55571 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55572 return (void *)((wxObject *) ((wxMenuItem *) x));
55573 }
55574 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55575 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55576 }
55577 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55578 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55579 }
55580 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55581 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55582 }
55583 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55584 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55585 }
55586 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55587 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55588 }
55589 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55590 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55591 }
55592 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55593 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
55594 }
55595 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
55596 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
55597 }
55598 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
55599 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
55600 }
55601 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
55602 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
55603 }
55604 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
55605 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
55606 }
55607 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
55608 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
55609 }
55610 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
55611 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
55612 }
55613 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
55614 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
55615 }
55616 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
55617 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55618 }
55619 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
55620 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55621 }
55622 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
55623 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
55624 }
55625 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
55626 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
55627 }
55628 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
55629 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
55630 }
55631 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
55632 return (void *)((wxObject *) ((wxImageHandler *) x));
55633 }
55634 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
55635 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
55636 }
55637 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
55638 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
55639 }
55640 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
55641 return (void *)((wxObject *) ((wxEvtHandler *) x));
55642 }
55643 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
55644 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
55645 }
55646 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
55647 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55648 }
55649 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
55650 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
55651 }
55652 static void *_p_wxImageTo_p_wxObject(void *x) {
55653 return (void *)((wxObject *) ((wxImage *) x));
55654 }
55655 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
55656 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
55657 }
55658 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
55659 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55660 }
55661 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
55662 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
55663 }
55664 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
55665 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
55666 }
55667 static void *_p_wxWindowTo_p_wxObject(void *x) {
55668 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
55669 }
55670 static void *_p_wxMenuTo_p_wxObject(void *x) {
55671 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
55672 }
55673 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
55674 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
55675 }
55676 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
55677 return (void *)((wxObject *) ((wxFileSystem *) x));
55678 }
55679 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
55680 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
55681 }
55682 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55683 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55684 }
55685 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55686 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55687 }
55688 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55689 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55690 }
55691 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55692 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55693 }
55694 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55695 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55696 }
55697 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55698 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55699 }
55700 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55701 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55702 }
55703 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55704 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55705 }
55706 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55707 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55708 }
55709 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55710 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55711 }
55712 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55713 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55714 }
55715 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55716 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55717 }
55718 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55719 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55720 }
55721 static void *_p_wxControlTo_p_wxWindow(void *x) {
55722 return (void *)((wxWindow *) ((wxControl *) x));
55723 }
55724 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55725 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55726 }
55727 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55728 return (void *)((wxWindow *) ((wxMenuBar *) x));
55729 }
55730 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55731 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55732 }
55733 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55734 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55735 }
55736 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55737 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55738 }
55739 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55740 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55741 }
55742 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55743 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55744 }
55745 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55746 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55747 }
55748 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55749 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55750 }
55751 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55752 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55753 }
55754 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55755 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55756 }
55757 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55758 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55759 }
55760 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55761 return (void *)((wxValidator *) ((wxPyValidator *) x));
55762 }
55763 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55764 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55765 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};
55766 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55767 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55768 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55769 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55770 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55771 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55772 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55773 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55774 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55775 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55776 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55777 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55778 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55779 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55780 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55781 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55782 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55783 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55784 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55785 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55786 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55787 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55788 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55789 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55790 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55791 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55792 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55793 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55794 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55795 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55796 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55797 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55798 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55799 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55800 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55801 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55802 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55803 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55804 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55805 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55806 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55807 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55808 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55809 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55810 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55811 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55812 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55813 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55814 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55815 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55816 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55817 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55818 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55819 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55820 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55821 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55822 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55823 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55824 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55825 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55826 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55827 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55828 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55829 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55830 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55831 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55832 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55833 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55834 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55835 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55836 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55837 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55838 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55839 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55840 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55841 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55842 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55843 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55844 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55845 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55846 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55847 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55848 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55849 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55850 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55851 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55852 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55853 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55854 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55855 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55856 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55857 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55858 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55859 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55860 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55861 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55862 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55863 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55864 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55865 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55866 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55867 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55868 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55869 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55870 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55871 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55872 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55873 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55874 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55875 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55876 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55877 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55878 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55879 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55880 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55881 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55882 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55883 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55884 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55885 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55886 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55887 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55888 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55889 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55890 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55891 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55892 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55893 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55894 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55895
55896 static swig_type_info *swig_type_initial[] = {
55897 &_swigt__p_buffer,
55898 &_swigt__p_char,
55899 &_swigt__p_form_ops_t,
55900 &_swigt__p_int,
55901 &_swigt__p_long,
55902 &_swigt__p_unsigned_char,
55903 &_swigt__p_unsigned_int,
55904 &_swigt__p_unsigned_long,
55905 &_swigt__p_wxANIHandler,
55906 &_swigt__p_wxAcceleratorEntry,
55907 &_swigt__p_wxAcceleratorTable,
55908 &_swigt__p_wxActivateEvent,
55909 &_swigt__p_wxAppTraits,
55910 &_swigt__p_wxArrayString,
55911 &_swigt__p_wxBMPHandler,
55912 &_swigt__p_wxBitmap,
55913 &_swigt__p_wxBoxSizer,
55914 &_swigt__p_wxButton,
55915 &_swigt__p_wxCURHandler,
55916 &_swigt__p_wxCaret,
55917 &_swigt__p_wxChildFocusEvent,
55918 &_swigt__p_wxClipboardTextEvent,
55919 &_swigt__p_wxCloseEvent,
55920 &_swigt__p_wxColour,
55921 &_swigt__p_wxCommandEvent,
55922 &_swigt__p_wxContextMenuEvent,
55923 &_swigt__p_wxControl,
55924 &_swigt__p_wxControlWithItems,
55925 &_swigt__p_wxCursor,
55926 &_swigt__p_wxDC,
55927 &_swigt__p_wxDateEvent,
55928 &_swigt__p_wxDateTime,
55929 &_swigt__p_wxDisplayChangedEvent,
55930 &_swigt__p_wxDropFilesEvent,
55931 &_swigt__p_wxDuplexMode,
55932 &_swigt__p_wxEraseEvent,
55933 &_swigt__p_wxEvent,
55934 &_swigt__p_wxEventLoop,
55935 &_swigt__p_wxEventLoopActivator,
55936 &_swigt__p_wxEvtHandler,
55937 &_swigt__p_wxFSFile,
55938 &_swigt__p_wxFileSystem,
55939 &_swigt__p_wxFileSystemHandler,
55940 &_swigt__p_wxFlexGridSizer,
55941 &_swigt__p_wxFocusEvent,
55942 &_swigt__p_wxFont,
55943 &_swigt__p_wxFrame,
55944 &_swigt__p_wxGBPosition,
55945 &_swigt__p_wxGBSizerItem,
55946 &_swigt__p_wxGBSpan,
55947 &_swigt__p_wxGIFHandler,
55948 &_swigt__p_wxGridBagSizer,
55949 &_swigt__p_wxGridSizer,
55950 &_swigt__p_wxHelpEvent__Origin,
55951 &_swigt__p_wxICOHandler,
55952 &_swigt__p_wxIconizeEvent,
55953 &_swigt__p_wxIdleEvent,
55954 &_swigt__p_wxImage,
55955 &_swigt__p_wxImageHandler,
55956 &_swigt__p_wxImageHistogram,
55957 &_swigt__p_wxImage_HSVValue,
55958 &_swigt__p_wxImage_RGBValue,
55959 &_swigt__p_wxIndividualLayoutConstraint,
55960 &_swigt__p_wxInitDialogEvent,
55961 &_swigt__p_wxInputStream,
55962 &_swigt__p_wxInternetFSHandler,
55963 &_swigt__p_wxItemContainer,
55964 &_swigt__p_wxJPEGHandler,
55965 &_swigt__p_wxKeyEvent,
55966 &_swigt__p_wxLayoutConstraints,
55967 &_swigt__p_wxMaximizeEvent,
55968 &_swigt__p_wxMemoryFSHandler,
55969 &_swigt__p_wxMenu,
55970 &_swigt__p_wxMenuBar,
55971 &_swigt__p_wxMenuBarBase,
55972 &_swigt__p_wxMenuEvent,
55973 &_swigt__p_wxMenuItem,
55974 &_swigt__p_wxMouseCaptureChangedEvent,
55975 &_swigt__p_wxMouseCaptureLostEvent,
55976 &_swigt__p_wxMouseEvent,
55977 &_swigt__p_wxMoveEvent,
55978 &_swigt__p_wxNavigationKeyEvent,
55979 &_swigt__p_wxNcPaintEvent,
55980 &_swigt__p_wxNotifyEvent,
55981 &_swigt__p_wxObject,
55982 &_swigt__p_wxOutputStream,
55983 &_swigt__p_wxPCXHandler,
55984 &_swigt__p_wxPNGHandler,
55985 &_swigt__p_wxPNMHandler,
55986 &_swigt__p_wxPaintEvent,
55987 &_swigt__p_wxPaletteChangedEvent,
55988 &_swigt__p_wxPaperSize,
55989 &_swigt__p_wxPoint,
55990 &_swigt__p_wxPoint2D,
55991 &_swigt__p_wxPropagateOnce,
55992 &_swigt__p_wxPropagationDisabler,
55993 &_swigt__p_wxPyApp,
55994 &_swigt__p_wxPyCommandEvent,
55995 &_swigt__p_wxPyDropTarget,
55996 &_swigt__p_wxPyEvent,
55997 &_swigt__p_wxPyFileSystemHandler,
55998 &_swigt__p_wxPyImageHandler,
55999 &_swigt__p_wxPyInputStream,
56000 &_swigt__p_wxPySizer,
56001 &_swigt__p_wxPyValidator,
56002 &_swigt__p_wxQuantize,
56003 &_swigt__p_wxQueryNewPaletteEvent,
56004 &_swigt__p_wxRealPoint,
56005 &_swigt__p_wxRect,
56006 &_swigt__p_wxRegion,
56007 &_swigt__p_wxScrollEvent,
56008 &_swigt__p_wxScrollWinEvent,
56009 &_swigt__p_wxSetCursorEvent,
56010 &_swigt__p_wxShowEvent,
56011 &_swigt__p_wxSize,
56012 &_swigt__p_wxSizeEvent,
56013 &_swigt__p_wxSizer,
56014 &_swigt__p_wxSizerItem,
56015 &_swigt__p_wxStaticBox,
56016 &_swigt__p_wxStaticBoxSizer,
56017 &_swigt__p_wxStdDialogButtonSizer,
56018 &_swigt__p_wxSysColourChangedEvent,
56019 &_swigt__p_wxTIFFHandler,
56020 &_swigt__p_wxToolTip,
56021 &_swigt__p_wxUpdateUIEvent,
56022 &_swigt__p_wxValidator,
56023 &_swigt__p_wxVisualAttributes,
56024 &_swigt__p_wxWindow,
56025 &_swigt__p_wxWindowCreateEvent,
56026 &_swigt__p_wxWindowDestroyEvent,
56027 &_swigt__p_wxXPMHandler,
56028 &_swigt__p_wxZipFSHandler,
56029 };
56030
56031 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56032 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56033 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56034 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56035 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56036 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56037 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56038 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56039 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56040 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56041 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56042 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56043 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56044 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56045 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}};
56046 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56047 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}};
56048 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56049 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}};
56050 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56051 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56052 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56053 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56054 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56055 static swig_cast_info _swigc__p_wxCommandEvent[] = { {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxCommandEvent, 0, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxCommandEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxCommandEvent, 0, 0},{0, 0, 0, 0}};
56056 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56057 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}};
56058 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56059 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56060 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56061 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56062 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56063 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56064 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56065 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56066 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56067 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
56068 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56069 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56070 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}};
56071 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56072 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56073 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}};
56074 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}};
56075 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56076 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56077 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56078 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56079 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56080 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56081 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56082 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56083 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}};
56084 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56085 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}};
56086 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56087 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56088 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56089 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}};
56090 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56091 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56092 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56093 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56094 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56095 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56096 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56097 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}};
56098 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56099 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56100 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56101 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56102 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56103 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56104 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56105 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56106 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56107 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56108 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56109 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56110 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56111 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56112 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56113 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56114 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56115 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
56116 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56117 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56118 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56119 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56120 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56121 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56122 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56123 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56124 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56125 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56126 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56127 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56128 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56129 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56130 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56131 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56132 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56133 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56134 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56135 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56136 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56137 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56138 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56139 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56140 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56141 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56142 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56143 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56144 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56145 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56146 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56147 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}};
56148 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}};
56149 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56150 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56151 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56152 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56153 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56154 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56155 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56156 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}};
56157 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56158 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}};
56159 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56160 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56161 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56162 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56163
56164 static swig_cast_info *swig_cast_initial[] = {
56165 _swigc__p_buffer,
56166 _swigc__p_char,
56167 _swigc__p_form_ops_t,
56168 _swigc__p_int,
56169 _swigc__p_long,
56170 _swigc__p_unsigned_char,
56171 _swigc__p_unsigned_int,
56172 _swigc__p_unsigned_long,
56173 _swigc__p_wxANIHandler,
56174 _swigc__p_wxAcceleratorEntry,
56175 _swigc__p_wxAcceleratorTable,
56176 _swigc__p_wxActivateEvent,
56177 _swigc__p_wxAppTraits,
56178 _swigc__p_wxArrayString,
56179 _swigc__p_wxBMPHandler,
56180 _swigc__p_wxBitmap,
56181 _swigc__p_wxBoxSizer,
56182 _swigc__p_wxButton,
56183 _swigc__p_wxCURHandler,
56184 _swigc__p_wxCaret,
56185 _swigc__p_wxChildFocusEvent,
56186 _swigc__p_wxClipboardTextEvent,
56187 _swigc__p_wxCloseEvent,
56188 _swigc__p_wxColour,
56189 _swigc__p_wxCommandEvent,
56190 _swigc__p_wxContextMenuEvent,
56191 _swigc__p_wxControl,
56192 _swigc__p_wxControlWithItems,
56193 _swigc__p_wxCursor,
56194 _swigc__p_wxDC,
56195 _swigc__p_wxDateEvent,
56196 _swigc__p_wxDateTime,
56197 _swigc__p_wxDisplayChangedEvent,
56198 _swigc__p_wxDropFilesEvent,
56199 _swigc__p_wxDuplexMode,
56200 _swigc__p_wxEraseEvent,
56201 _swigc__p_wxEvent,
56202 _swigc__p_wxEventLoop,
56203 _swigc__p_wxEventLoopActivator,
56204 _swigc__p_wxEvtHandler,
56205 _swigc__p_wxFSFile,
56206 _swigc__p_wxFileSystem,
56207 _swigc__p_wxFileSystemHandler,
56208 _swigc__p_wxFlexGridSizer,
56209 _swigc__p_wxFocusEvent,
56210 _swigc__p_wxFont,
56211 _swigc__p_wxFrame,
56212 _swigc__p_wxGBPosition,
56213 _swigc__p_wxGBSizerItem,
56214 _swigc__p_wxGBSpan,
56215 _swigc__p_wxGIFHandler,
56216 _swigc__p_wxGridBagSizer,
56217 _swigc__p_wxGridSizer,
56218 _swigc__p_wxHelpEvent__Origin,
56219 _swigc__p_wxICOHandler,
56220 _swigc__p_wxIconizeEvent,
56221 _swigc__p_wxIdleEvent,
56222 _swigc__p_wxImage,
56223 _swigc__p_wxImageHandler,
56224 _swigc__p_wxImageHistogram,
56225 _swigc__p_wxImage_HSVValue,
56226 _swigc__p_wxImage_RGBValue,
56227 _swigc__p_wxIndividualLayoutConstraint,
56228 _swigc__p_wxInitDialogEvent,
56229 _swigc__p_wxInputStream,
56230 _swigc__p_wxInternetFSHandler,
56231 _swigc__p_wxItemContainer,
56232 _swigc__p_wxJPEGHandler,
56233 _swigc__p_wxKeyEvent,
56234 _swigc__p_wxLayoutConstraints,
56235 _swigc__p_wxMaximizeEvent,
56236 _swigc__p_wxMemoryFSHandler,
56237 _swigc__p_wxMenu,
56238 _swigc__p_wxMenuBar,
56239 _swigc__p_wxMenuBarBase,
56240 _swigc__p_wxMenuEvent,
56241 _swigc__p_wxMenuItem,
56242 _swigc__p_wxMouseCaptureChangedEvent,
56243 _swigc__p_wxMouseCaptureLostEvent,
56244 _swigc__p_wxMouseEvent,
56245 _swigc__p_wxMoveEvent,
56246 _swigc__p_wxNavigationKeyEvent,
56247 _swigc__p_wxNcPaintEvent,
56248 _swigc__p_wxNotifyEvent,
56249 _swigc__p_wxObject,
56250 _swigc__p_wxOutputStream,
56251 _swigc__p_wxPCXHandler,
56252 _swigc__p_wxPNGHandler,
56253 _swigc__p_wxPNMHandler,
56254 _swigc__p_wxPaintEvent,
56255 _swigc__p_wxPaletteChangedEvent,
56256 _swigc__p_wxPaperSize,
56257 _swigc__p_wxPoint,
56258 _swigc__p_wxPoint2D,
56259 _swigc__p_wxPropagateOnce,
56260 _swigc__p_wxPropagationDisabler,
56261 _swigc__p_wxPyApp,
56262 _swigc__p_wxPyCommandEvent,
56263 _swigc__p_wxPyDropTarget,
56264 _swigc__p_wxPyEvent,
56265 _swigc__p_wxPyFileSystemHandler,
56266 _swigc__p_wxPyImageHandler,
56267 _swigc__p_wxPyInputStream,
56268 _swigc__p_wxPySizer,
56269 _swigc__p_wxPyValidator,
56270 _swigc__p_wxQuantize,
56271 _swigc__p_wxQueryNewPaletteEvent,
56272 _swigc__p_wxRealPoint,
56273 _swigc__p_wxRect,
56274 _swigc__p_wxRegion,
56275 _swigc__p_wxScrollEvent,
56276 _swigc__p_wxScrollWinEvent,
56277 _swigc__p_wxSetCursorEvent,
56278 _swigc__p_wxShowEvent,
56279 _swigc__p_wxSize,
56280 _swigc__p_wxSizeEvent,
56281 _swigc__p_wxSizer,
56282 _swigc__p_wxSizerItem,
56283 _swigc__p_wxStaticBox,
56284 _swigc__p_wxStaticBoxSizer,
56285 _swigc__p_wxStdDialogButtonSizer,
56286 _swigc__p_wxSysColourChangedEvent,
56287 _swigc__p_wxTIFFHandler,
56288 _swigc__p_wxToolTip,
56289 _swigc__p_wxUpdateUIEvent,
56290 _swigc__p_wxValidator,
56291 _swigc__p_wxVisualAttributes,
56292 _swigc__p_wxWindow,
56293 _swigc__p_wxWindowCreateEvent,
56294 _swigc__p_wxWindowDestroyEvent,
56295 _swigc__p_wxXPMHandler,
56296 _swigc__p_wxZipFSHandler,
56297 };
56298
56299
56300 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56301
56302 static swig_const_info swig_const_table[] = {
56303 {0, 0, 0, 0.0, 0, 0}};
56304
56305 #ifdef __cplusplus
56306 }
56307 #endif
56308 /* -----------------------------------------------------------------------------
56309 * Type initialization:
56310 * This problem is tough by the requirement that no dynamic
56311 * memory is used. Also, since swig_type_info structures store pointers to
56312 * swig_cast_info structures and swig_cast_info structures store pointers back
56313 * to swig_type_info structures, we need some lookup code at initialization.
56314 * The idea is that swig generates all the structures that are needed.
56315 * The runtime then collects these partially filled structures.
56316 * The SWIG_InitializeModule function takes these initial arrays out of
56317 * swig_module, and does all the lookup, filling in the swig_module.types
56318 * array with the correct data and linking the correct swig_cast_info
56319 * structures together.
56320 *
56321 * The generated swig_type_info structures are assigned staticly to an initial
56322 * array. We just loop though that array, and handle each type individually.
56323 * First we lookup if this type has been already loaded, and if so, use the
56324 * loaded structure instead of the generated one. Then we have to fill in the
56325 * cast linked list. The cast data is initially stored in something like a
56326 * two-dimensional array. Each row corresponds to a type (there are the same
56327 * number of rows as there are in the swig_type_initial array). Each entry in
56328 * a column is one of the swig_cast_info structures for that type.
56329 * The cast_initial array is actually an array of arrays, because each row has
56330 * a variable number of columns. So to actually build the cast linked list,
56331 * we find the array of casts associated with the type, and loop through it
56332 * adding the casts to the list. The one last trick we need to do is making
56333 * sure the type pointer in the swig_cast_info struct is correct.
56334 *
56335 * First off, we lookup the cast->type name to see if it is already loaded.
56336 * There are three cases to handle:
56337 * 1) If the cast->type has already been loaded AND the type we are adding
56338 * casting info to has not been loaded (it is in this module), THEN we
56339 * replace the cast->type pointer with the type pointer that has already
56340 * been loaded.
56341 * 2) If BOTH types (the one we are adding casting info to, and the
56342 * cast->type) are loaded, THEN the cast info has already been loaded by
56343 * the previous module so we just ignore it.
56344 * 3) Finally, if cast->type has not already been loaded, then we add that
56345 * swig_cast_info to the linked list (because the cast->type) pointer will
56346 * be correct.
56347 * ----------------------------------------------------------------------------- */
56348
56349 #ifdef __cplusplus
56350 extern "C" {
56351 #if 0
56352 } /* c-mode */
56353 #endif
56354 #endif
56355
56356 #if 0
56357 #define SWIGRUNTIME_DEBUG
56358 #endif
56359
56360 SWIGRUNTIME void
56361 SWIG_InitializeModule(void *clientdata) {
56362 size_t i;
56363 swig_module_info *module_head;
56364 static int init_run = 0;
56365
56366 clientdata = clientdata;
56367
56368 if (init_run) return;
56369 init_run = 1;
56370
56371 /* Initialize the swig_module */
56372 swig_module.type_initial = swig_type_initial;
56373 swig_module.cast_initial = swig_cast_initial;
56374
56375 /* Try and load any already created modules */
56376 module_head = SWIG_GetModule(clientdata);
56377 if (module_head) {
56378 swig_module.next = module_head->next;
56379 module_head->next = &swig_module;
56380 } else {
56381 /* This is the first module loaded */
56382 swig_module.next = &swig_module;
56383 SWIG_SetModule(clientdata, &swig_module);
56384 }
56385
56386 /* Now work on filling in swig_module.types */
56387 #ifdef SWIGRUNTIME_DEBUG
56388 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56389 #endif
56390 for (i = 0; i < swig_module.size; ++i) {
56391 swig_type_info *type = 0;
56392 swig_type_info *ret;
56393 swig_cast_info *cast;
56394
56395 #ifdef SWIGRUNTIME_DEBUG
56396 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56397 #endif
56398
56399 /* if there is another module already loaded */
56400 if (swig_module.next != &swig_module) {
56401 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56402 }
56403 if (type) {
56404 /* Overwrite clientdata field */
56405 #ifdef SWIGRUNTIME_DEBUG
56406 printf("SWIG_InitializeModule: found type %s\n", type->name);
56407 #endif
56408 if (swig_module.type_initial[i]->clientdata) {
56409 type->clientdata = swig_module.type_initial[i]->clientdata;
56410 #ifdef SWIGRUNTIME_DEBUG
56411 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56412 #endif
56413 }
56414 } else {
56415 type = swig_module.type_initial[i];
56416 }
56417
56418 /* Insert casting types */
56419 cast = swig_module.cast_initial[i];
56420 while (cast->type) {
56421 /* Don't need to add information already in the list */
56422 ret = 0;
56423 #ifdef SWIGRUNTIME_DEBUG
56424 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56425 #endif
56426 if (swig_module.next != &swig_module) {
56427 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56428 #ifdef SWIGRUNTIME_DEBUG
56429 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56430 #endif
56431 }
56432 if (ret) {
56433 if (type == swig_module.type_initial[i]) {
56434 #ifdef SWIGRUNTIME_DEBUG
56435 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56436 #endif
56437 cast->type = ret;
56438 ret = 0;
56439 } else {
56440 /* Check for casting already in the list */
56441 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56442 #ifdef SWIGRUNTIME_DEBUG
56443 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56444 #endif
56445 if (!ocast) ret = 0;
56446 }
56447 }
56448
56449 if (!ret) {
56450 #ifdef SWIGRUNTIME_DEBUG
56451 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56452 #endif
56453 if (type->cast) {
56454 type->cast->prev = cast;
56455 cast->next = type->cast;
56456 }
56457 type->cast = cast;
56458 }
56459 cast++;
56460 }
56461 /* Set entry in modules->types array equal to the type */
56462 swig_module.types[i] = type;
56463 }
56464 swig_module.types[i] = 0;
56465
56466 #ifdef SWIGRUNTIME_DEBUG
56467 printf("**** SWIG_InitializeModule: Cast List ******\n");
56468 for (i = 0; i < swig_module.size; ++i) {
56469 int j = 0;
56470 swig_cast_info *cast = swig_module.cast_initial[i];
56471 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56472 while (cast->type) {
56473 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56474 cast++;
56475 ++j;
56476 }
56477 printf("---- Total casts: %d\n",j);
56478 }
56479 printf("**** SWIG_InitializeModule: Cast List ******\n");
56480 #endif
56481 }
56482
56483 /* This function will propagate the clientdata field of type to
56484 * any new swig_type_info structures that have been added into the list
56485 * of equivalent types. It is like calling
56486 * SWIG_TypeClientData(type, clientdata) a second time.
56487 */
56488 SWIGRUNTIME void
56489 SWIG_PropagateClientData(void) {
56490 size_t i;
56491 swig_cast_info *equiv;
56492 static int init_run = 0;
56493
56494 if (init_run) return;
56495 init_run = 1;
56496
56497 for (i = 0; i < swig_module.size; i++) {
56498 if (swig_module.types[i]->clientdata) {
56499 equiv = swig_module.types[i]->cast;
56500 while (equiv) {
56501 if (!equiv->converter) {
56502 if (equiv->type && !equiv->type->clientdata)
56503 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56504 }
56505 equiv = equiv->next;
56506 }
56507 }
56508 }
56509 }
56510
56511 #ifdef __cplusplus
56512 #if 0
56513 {
56514 /* c-mode */
56515 #endif
56516 }
56517 #endif
56518
56519
56520
56521 #ifdef __cplusplus
56522 extern "C" {
56523 #endif
56524
56525 /* Python-specific SWIG API */
56526 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56527 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56528 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56529
56530 /* -----------------------------------------------------------------------------
56531 * global variable support code.
56532 * ----------------------------------------------------------------------------- */
56533
56534 typedef struct swig_globalvar {
56535 char *name; /* Name of global variable */
56536 PyObject *(*get_attr)(void); /* Return the current value */
56537 int (*set_attr)(PyObject *); /* Set the value */
56538 struct swig_globalvar *next;
56539 } swig_globalvar;
56540
56541 typedef struct swig_varlinkobject {
56542 PyObject_HEAD
56543 swig_globalvar *vars;
56544 } swig_varlinkobject;
56545
56546 SWIGINTERN PyObject *
56547 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56548 return PyString_FromString("<Swig global variables>");
56549 }
56550
56551 SWIGINTERN PyObject *
56552 swig_varlink_str(swig_varlinkobject *v) {
56553 PyObject *str = PyString_FromString("(");
56554 swig_globalvar *var;
56555 for (var = v->vars; var; var=var->next) {
56556 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56557 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56558 }
56559 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56560 return str;
56561 }
56562
56563 SWIGINTERN int
56564 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56565 PyObject *str = swig_varlink_str(v);
56566 fprintf(fp,"Swig global variables ");
56567 fprintf(fp,"%s\n", PyString_AsString(str));
56568 Py_DECREF(str);
56569 return 0;
56570 }
56571
56572 SWIGINTERN void
56573 swig_varlink_dealloc(swig_varlinkobject *v) {
56574 swig_globalvar *var = v->vars;
56575 while (var) {
56576 swig_globalvar *n = var->next;
56577 free(var->name);
56578 free(var);
56579 var = n;
56580 }
56581 }
56582
56583 SWIGINTERN PyObject *
56584 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56585 PyObject *res = NULL;
56586 swig_globalvar *var = v->vars;
56587 while (var) {
56588 if (strcmp(var->name,n) == 0) {
56589 res = (*var->get_attr)();
56590 break;
56591 }
56592 var = var->next;
56593 }
56594 if (res == NULL && !PyErr_Occurred()) {
56595 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56596 }
56597 return res;
56598 }
56599
56600 SWIGINTERN int
56601 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
56602 int res = 1;
56603 swig_globalvar *var = v->vars;
56604 while (var) {
56605 if (strcmp(var->name,n) == 0) {
56606 res = (*var->set_attr)(p);
56607 break;
56608 }
56609 var = var->next;
56610 }
56611 if (res == 1 && !PyErr_Occurred()) {
56612 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56613 }
56614 return res;
56615 }
56616
56617 SWIGINTERN PyTypeObject*
56618 swig_varlink_type(void) {
56619 static char varlink__doc__[] = "Swig var link object";
56620 static PyTypeObject varlink_type;
56621 static int type_init = 0;
56622 if (!type_init) {
56623 const PyTypeObject tmp
56624 = {
56625 PyObject_HEAD_INIT(NULL)
56626 0, /* Number of items in variable part (ob_size) */
56627 (char *)"swigvarlink", /* Type name (tp_name) */
56628 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
56629 0, /* Itemsize (tp_itemsize) */
56630 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
56631 (printfunc) swig_varlink_print, /* Print (tp_print) */
56632 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
56633 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
56634 0, /* tp_compare */
56635 (reprfunc) swig_varlink_repr, /* tp_repr */
56636 0, /* tp_as_number */
56637 0, /* tp_as_sequence */
56638 0, /* tp_as_mapping */
56639 0, /* tp_hash */
56640 0, /* tp_call */
56641 (reprfunc)swig_varlink_str, /* tp_str */
56642 0, /* tp_getattro */
56643 0, /* tp_setattro */
56644 0, /* tp_as_buffer */
56645 0, /* tp_flags */
56646 varlink__doc__, /* tp_doc */
56647 0, /* tp_traverse */
56648 0, /* tp_clear */
56649 0, /* tp_richcompare */
56650 0, /* tp_weaklistoffset */
56651 #if PY_VERSION_HEX >= 0x02020000
56652 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
56653 #endif
56654 #if PY_VERSION_HEX >= 0x02030000
56655 0, /* tp_del */
56656 #endif
56657 #ifdef COUNT_ALLOCS
56658 0,0,0,0 /* tp_alloc -> tp_next */
56659 #endif
56660 };
56661 varlink_type = tmp;
56662 varlink_type.ob_type = &PyType_Type;
56663 type_init = 1;
56664 }
56665 return &varlink_type;
56666 }
56667
56668 /* Create a variable linking object for use later */
56669 SWIGINTERN PyObject *
56670 SWIG_Python_newvarlink(void) {
56671 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
56672 if (result) {
56673 result->vars = 0;
56674 }
56675 return ((PyObject*) result);
56676 }
56677
56678 SWIGINTERN void
56679 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
56680 swig_varlinkobject *v = (swig_varlinkobject *) p;
56681 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
56682 if (gv) {
56683 size_t size = strlen(name)+1;
56684 gv->name = (char *)malloc(size);
56685 if (gv->name) {
56686 strncpy(gv->name,name,size);
56687 gv->get_attr = get_attr;
56688 gv->set_attr = set_attr;
56689 gv->next = v->vars;
56690 }
56691 }
56692 v->vars = gv;
56693 }
56694
56695 SWIGINTERN PyObject *
56696 SWIG_globals() {
56697 static PyObject *_SWIG_globals = 0;
56698 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56699 return _SWIG_globals;
56700 }
56701
56702 /* -----------------------------------------------------------------------------
56703 * constants/methods manipulation
56704 * ----------------------------------------------------------------------------- */
56705
56706 /* Install Constants */
56707 SWIGINTERN void
56708 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56709 PyObject *obj = 0;
56710 size_t i;
56711 for (i = 0; constants[i].type; ++i) {
56712 switch(constants[i].type) {
56713 case SWIG_PY_POINTER:
56714 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56715 break;
56716 case SWIG_PY_BINARY:
56717 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56718 break;
56719 default:
56720 obj = 0;
56721 break;
56722 }
56723 if (obj) {
56724 PyDict_SetItemString(d, constants[i].name, obj);
56725 Py_DECREF(obj);
56726 }
56727 }
56728 }
56729
56730 /* -----------------------------------------------------------------------------*/
56731 /* Fix SwigMethods to carry the callback ptrs when needed */
56732 /* -----------------------------------------------------------------------------*/
56733
56734 SWIGINTERN void
56735 SWIG_Python_FixMethods(PyMethodDef *methods,
56736 swig_const_info *const_table,
56737 swig_type_info **types,
56738 swig_type_info **types_initial) {
56739 size_t i;
56740 for (i = 0; methods[i].ml_name; ++i) {
56741 const char *c = methods[i].ml_doc;
56742 if (c && (c = strstr(c, "swig_ptr: "))) {
56743 int j;
56744 swig_const_info *ci = 0;
56745 const char *name = c + 10;
56746 for (j = 0; const_table[j].type; ++j) {
56747 if (strncmp(const_table[j].name, name,
56748 strlen(const_table[j].name)) == 0) {
56749 ci = &(const_table[j]);
56750 break;
56751 }
56752 }
56753 if (ci) {
56754 size_t shift = (ci->ptype) - types;
56755 swig_type_info *ty = types_initial[shift];
56756 size_t ldoc = (c - methods[i].ml_doc);
56757 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56758 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56759 if (ndoc) {
56760 char *buff = ndoc;
56761 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56762 if (ptr) {
56763 strncpy(buff, methods[i].ml_doc, ldoc);
56764 buff += ldoc;
56765 strncpy(buff, "swig_ptr: ", 10);
56766 buff += 10;
56767 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56768 methods[i].ml_doc = ndoc;
56769 }
56770 }
56771 }
56772 }
56773 }
56774 }
56775
56776 #ifdef __cplusplus
56777 }
56778 #endif
56779
56780 /* -----------------------------------------------------------------------------*
56781 * Partial Init method
56782 * -----------------------------------------------------------------------------*/
56783
56784 #ifdef __cplusplus
56785 extern "C"
56786 #endif
56787 SWIGEXPORT void SWIG_init(void) {
56788 PyObject *m, *d;
56789
56790 /* Fix SwigMethods to carry the callback ptrs when needed */
56791 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56792
56793 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56794 d = PyModule_GetDict(m);
56795
56796 SWIG_InitializeModule(0);
56797 SWIG_InstallConstants(d,swig_const_table);
56798
56799
56800
56801 #ifndef wxPyUSE_EXPORT
56802 // Make our API structure a CObject so other modules can import it
56803 // from this module.
56804 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56805 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56806 Py_XDECREF(cobj);
56807 #endif
56808
56809 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56810 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56811 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56812 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56813 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56814 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56815 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56816 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56817 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56818 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56819 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56820 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56821 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56822 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56823 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56824 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56825 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56826 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56827 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56828 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56829 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56830 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56831 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56832 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56833 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56834 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56835 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56836 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56837 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56838 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56839 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56840 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56841 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56842 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56843 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56844 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56845 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56846 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56847 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56848 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56849 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56850 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56851 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56852 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56853 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56854 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56855 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56856 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56857 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56858 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56859 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56860 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56861 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56862 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56863 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56864 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56865 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56866 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56867 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56868 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56869 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56870 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56871 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56872 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56873 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56874 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56875 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56876 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56877 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56878 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56879 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56880 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56881 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56882 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56883 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56884 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56885 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56886 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56887 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56888 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56889 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56890 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56891 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56892 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56893 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56894 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56895 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56896 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56897 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56898 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56899 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56900 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56901 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56902 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56903 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56904 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56905 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56906 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56907 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56908 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56909 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56910 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56911 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56912 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56913 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56914 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56915 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56916 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56917 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56918 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56919 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56920 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56921 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56922 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56923 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56924 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56925 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56926 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56927 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56928 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56929 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56930 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56931 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56932 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56933 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56934 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
56935 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56936 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56937 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56938 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56939 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56940 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56941 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56942 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56943 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56944 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56945 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56946 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56947 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56948 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56949 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56950 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56951 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56952 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56953 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56954 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
56955 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56956 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56957 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56958 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56959 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56960 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56961 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56962 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56963 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56964 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56965 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56966 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56967 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56968 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56969 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56970 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56971 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56972 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56973 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56974 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56975 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56976 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56977 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56978 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56979 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56980 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56981 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56982 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56983 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56984 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56985 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56986 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56987 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56988 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56989 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56990 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56991 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56992 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56993 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56994 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56995 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56996 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56997 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56998 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56999 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
57000 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
57001 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
57002 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
57003 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
57004 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
57005 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
57006 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
57007 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
57008 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
57009 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
57010 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
57011 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
57012 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57013 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57014 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57015 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57016 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57017 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57018 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57019 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57020 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57021 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57022 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57023 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57024 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57025 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57026 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57027 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57028 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57029 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57030 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57031 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57032 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57033 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57034 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57035 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57036 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57037 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57038 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57039 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57040 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57041 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57042 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57043 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57044 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57045 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57046 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57047 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57048 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57049 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57050 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57051 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57052 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57053 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57054 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57055 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57056 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57057 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57058 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57059 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57060 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57061 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57062 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57063 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57064 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57065 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57066 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57067 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57068 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57069 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57070 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57071 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57072 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57073 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57074 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57075 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57076 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57077 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57078 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57079 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57080 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57081 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57082 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57083 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57084 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57085 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57086 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57087 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57088 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57089 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57090 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57091 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57092 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57093 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57094 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57095 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57096 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57097 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57098 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57099 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57100 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57101 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57102 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57103 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57104 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57105 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57106 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57107 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57108 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57109 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57110 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57111 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57112 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57113 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57114 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57115 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57116 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57117 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57118 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57119 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57120 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57121 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57122 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57123 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57124 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57125 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57126 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57127 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57128 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57129 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57130 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57131 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57132 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57133 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57134 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57135 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57136 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57137 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57138 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57139 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57140 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57141 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57142 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57143 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57144 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57145 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57146 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57147 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57148 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57149 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57150 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57151 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57152 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57153 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57154 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57155 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57156 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57157 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57158 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57159 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57160 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57161 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57162 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57163 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57164 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57165 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57166 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57167 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57168 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57169 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57170 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57171 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57172 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57173 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57174 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57175 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57176 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57177 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57178 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57179 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57180 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57181 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57182 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57183 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57184 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57185 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57186 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57187 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57188 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57189 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57190 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57191 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57192 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57193 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57194 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57195 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57196 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57197 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57198 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57199 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57200 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57201 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57202 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57203 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57204 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57205 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57206 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57207 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57208 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57209 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57210 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57211 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57212 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57213 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57214 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57215 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57216 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57217 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57218 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57219 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57220 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57221 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57222 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57223 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57224 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57225 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57226 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57227 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57228 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57229 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57230 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57231 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57232 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57233 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57234 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57235 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57236 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57237 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57238 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57239 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57240 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57241 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57242 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57243 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57244 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57245 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57246 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57247 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57248 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57249 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57250 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57251 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57252 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57253 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57254 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57255 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57256 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57257 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57258 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57259 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57260 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57261 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57262 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57263 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57264 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57265 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57266 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57267 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57268 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57269 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57270 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57271 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57272 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57273 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57274 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57275 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57276 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57277 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57278 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57279 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57280 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57281 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57282 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57283 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57284 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57285 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57286 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57287 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57288 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57289 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57290 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57291 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57292 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57293 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57294 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57295 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57296 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57297 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57298 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57299 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57300 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57301 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57302 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57303 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57304 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57305 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57306 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57307 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57308 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57309 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57310 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57311 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57312 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57313 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57314 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57315 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57316 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57317 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57318 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57319 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57320 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57321 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57322 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57323 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57324 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57325 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57326 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57327 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57328 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57329 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57330 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57331 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57332 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57333 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57334 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57335 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57336 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57337 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57338 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57339 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57340 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57341 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57342 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57343 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57344 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57345 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57346 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57347 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57348 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57349 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57350 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57351 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57352 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57353 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57354 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57355 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57356 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57357 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57358 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57359 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57360 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57361 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57362 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57363 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57364 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57365 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57366 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57367 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57368 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57369 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57370 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57371 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57372 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57373 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57374 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57375 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57376 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57377 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57378 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57379 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57380 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57381 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57382 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57383 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57384 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57385 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57386 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57387 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57388 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57389 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57390 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57391 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57392 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57393 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57394 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57395 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57396 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57397 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57398 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57399 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57400 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57401 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57402 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57403 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57404 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57405 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57406 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57407 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
57408 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
57409 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
57410 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57411 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57412 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57413 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57414 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57415 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57416 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57417 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57418 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57419 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57420 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57421 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57422 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57423 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57424 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57425 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57426 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57427 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57428 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57429 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57430 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57431 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57432 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57433 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57434 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57435 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57436 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57437 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57438 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57439 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57440 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57441 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57442 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57443 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57444 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57445 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57446 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57447 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57448 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57449 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57450 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57451 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57452 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57453 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57454 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57455 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57456 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57457 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57458 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57459 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57460 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57461 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57462 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57463 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57464 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57465 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57466 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57467 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57468
57469 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57470
57471
57472 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57473
57474 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57475 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57476 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57477 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57478 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57479 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57480 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57481 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57482 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57483 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57484 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57485 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57486 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57487 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57488 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57489 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57490 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57491 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57492 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57493 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57494 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57495 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57496 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57497 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57498 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57499 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57500 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57501 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57502 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57503 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57504 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57505 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57506 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57507 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57508 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57509 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57510 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57511 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57512 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57513 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57514 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57515 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57516 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57517 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57518 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57519 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57520 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57521 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57522 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57523 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57524 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57525 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57526 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57527 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57528 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57529 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57530 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57531 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57532 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57533 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57534 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57535 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57536 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57537 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57538 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57539 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57540 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57541 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57542 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57543 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57544 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57545 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57546 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57547 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57548 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57549 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57550 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57551 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57552 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57553 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57554 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57555 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57556 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57557 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57558 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57559 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57560 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57561 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57562 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57563 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57564 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57565 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57566 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57567 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57568 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57569 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57570 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57571 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57572 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57573 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57574 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57575 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57576 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57577 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57578 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57579 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57580 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57581 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57582 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57583 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57584 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57585 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57586 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57587 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57588 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57589 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57590 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57591 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
57592 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
57593 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
57594 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
57595 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
57596 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
57597 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
57598 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
57599 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
57600 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
57601 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
57602 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
57603 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
57604 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
57605 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
57606 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
57607 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
57608 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
57609 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
57610 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
57611 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
57612 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
57613 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
57614 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
57615 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
57616 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
57617 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
57618 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
57619 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
57620 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
57621 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
57622 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
57623 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
57624 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
57625 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
57626 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
57627 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
57628 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
57629 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
57630 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
57631 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
57632 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
57633 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
57634 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
57635 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
57636 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
57637 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
57638 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
57639 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
57640 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
57641 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
57642 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
57643 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
57644 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
57645 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
57646 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
57647 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
57648 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
57649 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
57650 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
57651 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
57652 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
57653 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
57654 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
57655 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
57656 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
57657 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
57658 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
57659 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
57660 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
57661 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
57662 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
57663 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
57664 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
57665 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
57666 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
57667 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
57668 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
57669 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
57670 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
57671 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
57672 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
57673 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
57674 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
57675 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
57676 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
57677 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
57678 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
57679 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57680 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57681 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57682 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57683 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57684 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57685 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57686
57687 // Initialize threading, some globals and such
57688 __wxPyPreStart(d);
57689
57690
57691 // Although these are defined in __version__ they need to be here too so
57692 // that an assert can be done to ensure that the wxPython and the wxWindows
57693 // versions match.
57694 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57695 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57696 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57697
57698 }
57699
wxWidgets (Impactor)