]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Build the contents and index files for HtmlHelp
[wxWidgets.git] / wxPython / src / gtk / _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_wxLayoutDirection swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRegion swig_types[110]
2577 #define SWIGTYPE_p_wxScrollEvent swig_types[111]
2578 #define SWIGTYPE_p_wxScrollWinEvent swig_types[112]
2579 #define SWIGTYPE_p_wxSetCursorEvent swig_types[113]
2580 #define SWIGTYPE_p_wxShowEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSize swig_types[115]
2582 #define SWIGTYPE_p_wxSizeEvent swig_types[116]
2583 #define SWIGTYPE_p_wxSizer swig_types[117]
2584 #define SWIGTYPE_p_wxSizerItem swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBox swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[120]
2587 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[121]
2588 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[122]
2589 #define SWIGTYPE_p_wxTIFFHandler swig_types[123]
2590 #define SWIGTYPE_p_wxToolTip swig_types[124]
2591 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[125]
2592 #define SWIGTYPE_p_wxValidator swig_types[126]
2593 #define SWIGTYPE_p_wxVisualAttributes swig_types[127]
2594 #define SWIGTYPE_p_wxWindow swig_types[128]
2595 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[129]
2596 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[130]
2597 #define SWIGTYPE_p_wxXPMHandler swig_types[131]
2598 #define SWIGTYPE_p_wxZipFSHandler swig_types[132]
2599 static swig_type_info *swig_types[134];
2600 static swig_module_info swig_module = {swig_types, 133, 0, 0, 0, 0};
2601 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2602 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2603
2604 /* -------- TYPES TABLE (END) -------- */
2605
2606 #if (PY_VERSION_HEX <= 0x02000000)
2607 # if !defined(SWIG_PYTHON_CLASSIC)
2608 # error "This python version requires to use swig with the '-classic' option"
2609 # endif
2610 #endif
2611 #if (PY_VERSION_HEX <= 0x02020000)
2612 # error "This python version requires to use swig with the '-nomodern' option"
2613 #endif
2614 #if (PY_VERSION_HEX <= 0x02020000)
2615 # error "This python version requires to use swig with the '-nomodernargs' option"
2616 #endif
2617 #ifndef METH_O
2618 # error "This python version requires to use swig with the '-nofastunpack' option"
2619 #endif
2620
2621 /*-----------------------------------------------
2622 @(target):= _core_.so
2623 ------------------------------------------------*/
2624 #define SWIG_init init_core_
2625
2626 #define SWIG_name "_core_"
2627
2628 #define SWIGVERSION 0x010329
2629
2630
2631 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2632 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2633
2634
2635 #include <stdexcept>
2636
2637
2638 namespace swig {
2639 class PyObject_ptr {
2640 protected:
2641 PyObject *_obj;
2642
2643 public:
2644 PyObject_ptr() :_obj(0)
2645 {
2646 }
2647
2648 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2649 {
2650 Py_XINCREF(_obj);
2651 }
2652
2653 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2654 {
2655 if (initial_ref) Py_XINCREF(_obj);
2656 }
2657
2658 PyObject_ptr & operator=(const PyObject_ptr& item)
2659 {
2660 Py_XINCREF(item._obj);
2661 Py_XDECREF(_obj);
2662 _obj = item._obj;
2663 return *this;
2664 }
2665
2666 ~PyObject_ptr()
2667 {
2668 Py_XDECREF(_obj);
2669 }
2670
2671 operator PyObject *() const
2672 {
2673 return _obj;
2674 }
2675
2676 PyObject *operator->() const
2677 {
2678 return _obj;
2679 }
2680 };
2681 }
2682
2683
2684 namespace swig {
2685 struct PyObject_var : PyObject_ptr {
2686 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2687
2688 PyObject_var & operator = (PyObject* obj)
2689 {
2690 Py_XDECREF(_obj);
2691 _obj = obj;
2692 return *this;
2693 }
2694 };
2695 }
2696
2697
2698 #include "wx/wxPython/wxPython_int.h"
2699 #include "wx/wxPython/pyclasses.h"
2700 #include "wx/wxPython/twoitem.h"
2701
2702
2703 #ifndef wxPyUSE_EXPORT
2704 // Helper functions for dealing with SWIG objects and such. These are
2705 // located here so they know about the SWIG types and functions declared
2706 // in the wrapper code.
2707
2708 #include <wx/hashmap.h>
2709 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2710
2711
2712 // Maintains a hashmap of className to swig_type_info pointers. Given the
2713 // name of a class either looks up the type info in the cache, or scans the
2714 // SWIG tables for it.
2715 extern PyObject* wxPyPtrTypeMap;
2716 static
2717 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2718
2719 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2720
2721 if (typeInfoCache == NULL)
2722 typeInfoCache = new wxPyTypeInfoHashMap;
2723
2724 wxString name(className);
2725 swig_type_info* swigType = (*typeInfoCache)[name];
2726
2727 if (! swigType) {
2728 // it wasn't in the cache, so look it up from SWIG
2729 name.Append(wxT(" *"));
2730 swigType = SWIG_TypeQuery(name.mb_str());
2731
2732 // if it still wasn't found, try looking for a mapped name
2733 if (!swigType) {
2734 PyObject* item;
2735 name = className;
2736
2737 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2738 (char*)(const char*)name.mbc_str())) != NULL) {
2739 name = wxString(PyString_AsString(item), *wxConvCurrent);
2740 name.Append(wxT(" *"));
2741 swigType = SWIG_TypeQuery(name.mb_str());
2742 }
2743 }
2744 if (swigType) {
2745 // and add it to the map if found
2746 (*typeInfoCache)[className] = swigType;
2747 }
2748 }
2749 return swigType;
2750 }
2751
2752
2753 // Check if a class name is a type known to SWIG
2754 bool wxPyCheckSwigType(const wxChar* className) {
2755
2756 swig_type_info* swigType = wxPyFindSwigType(className);
2757 return swigType != NULL;
2758 }
2759
2760
2761 // Given a pointer to a C++ object and a class name, construct a Python proxy
2762 // object for it.
2763 PyObject* wxPyConstructObject(void* ptr,
2764 const wxChar* className,
2765 int setThisOwn) {
2766
2767 swig_type_info* swigType = wxPyFindSwigType(className);
2768 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2769
2770 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2771 }
2772
2773
2774 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2775 // Ensures that the proxy object is of the specified (or derived) type. If
2776 // not able to perform the conversion then a Python exception is set and the
2777 // error should be handled properly in the caller. Returns True on success.
2778 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2779 const wxChar* className) {
2780
2781 swig_type_info* swigType = wxPyFindSwigType(className);
2782 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2783
2784 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2785 }
2786
2787
2788
2789 // Make a SWIGified pointer object suitable for a .this attribute
2790 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2791
2792 PyObject* robj = NULL;
2793
2794 swig_type_info* swigType = wxPyFindSwigType(className);
2795 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2796
2797 robj = PySwigObject_New(ptr, swigType, 0);
2798 return robj;
2799 }
2800
2801
2802 // Python's PyInstance_Check does not return True for instances of new-style
2803 // classes. This should get close enough for both new and old classes but I
2804 // should re-evaluate the need for doing instance checks...
2805 bool wxPyInstance_Check(PyObject* obj) {
2806 return PyObject_HasAttrString(obj, "__class__") != 0;
2807 }
2808
2809
2810 // This one checks if the object is an instance of a SWIG proxy class (it has
2811 // a .this attribute, and the .this attribute is a PySwigObject.)
2812 bool wxPySwigInstance_Check(PyObject* obj) {
2813 static PyObject* this_str = NULL;
2814 if (this_str == NULL)
2815 this_str = PyString_FromString("this");
2816
2817 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2818 if (this_attr) {
2819 bool retval = (PySwigObject_Check(this_attr) != 0);
2820 Py_DECREF(this_attr);
2821 return retval;
2822 }
2823
2824 PyErr_Clear();
2825 return false;
2826 }
2827
2828
2829 // Export a C API in a struct. Other modules will be able to load this from
2830 // the wx._core_ module and will then have safe access to these functions,
2831 // even if they are located in another shared library.
2832 static wxPyCoreAPI API = {
2833
2834 wxPyCheckSwigType,
2835 wxPyConstructObject,
2836 wxPyConvertSwigPtr,
2837 wxPyMakeSwigPtr,
2838
2839 wxPyBeginAllowThreads,
2840 wxPyEndAllowThreads,
2841 wxPyBeginBlockThreads,
2842 wxPyEndBlockThreads,
2843
2844 wxPy_ConvertList,
2845
2846 wxString_in_helper,
2847 Py2wxString,
2848 wx2PyString,
2849
2850 byte_LIST_helper,
2851 int_LIST_helper,
2852 long_LIST_helper,
2853 string_LIST_helper,
2854 wxPoint_LIST_helper,
2855 wxBitmap_LIST_helper,
2856 wxString_LIST_helper,
2857 wxAcceleratorEntry_LIST_helper,
2858
2859 wxSize_helper,
2860 wxPoint_helper,
2861 wxRealPoint_helper,
2862 wxRect_helper,
2863 wxColour_helper,
2864 wxPoint2D_helper,
2865
2866 wxPySimple_typecheck,
2867 wxColour_typecheck,
2868
2869 wxPyCBH_setCallbackInfo,
2870 wxPyCBH_findCallback,
2871 wxPyCBH_callCallback,
2872 wxPyCBH_callCallbackObj,
2873 wxPyCBH_delete,
2874
2875 wxPyMake_wxObject,
2876 wxPyMake_wxSizer,
2877 wxPyPtrTypeMap_Add,
2878 wxPy2int_seq_helper,
2879 wxPy4int_seq_helper,
2880 wxArrayString2PyList_helper,
2881 wxArrayInt2PyList_helper,
2882
2883 wxPyClientData_dtor,
2884 wxPyUserData_dtor,
2885 wxPyOORClientData_dtor,
2886
2887 wxPyCBInputStream_create,
2888 wxPyCBInputStream_copy,
2889
2890 wxPyInstance_Check,
2891 wxPySwigInstance_Check,
2892
2893 wxPyCheckForApp
2894
2895 };
2896
2897 #endif
2898
2899
2900 #if !WXWIN_COMPATIBILITY_2_4
2901 #define wxHIDE_READONLY 0
2902 #endif
2903
2904
2905 #define SWIG_From_long PyInt_FromLong
2906
2907
2908 SWIGINTERNINLINE PyObject *
2909 SWIG_From_int (int value)
2910 {
2911 return SWIG_From_long (value);
2912 }
2913
2914 static const wxString wxPyEmptyString(wxEmptyString);
2915 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2916 return self->GetClassInfo()->GetClassName();
2917 }
2918 SWIGINTERN void wxObject_Destroy(wxObject *self){
2919 delete self;
2920 }
2921
2922 #ifndef __WXMAC__
2923 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2924 #endif
2925
2926
2927 #include <limits.h>
2928 #ifndef LLONG_MIN
2929 # define LLONG_MIN LONG_LONG_MIN
2930 #endif
2931 #ifndef LLONG_MAX
2932 # define LLONG_MAX LONG_LONG_MAX
2933 #endif
2934 #ifndef ULLONG_MAX
2935 # define ULLONG_MAX ULONG_LONG_MAX
2936 #endif
2937
2938
2939 SWIGINTERN int
2940 SWIG_AsVal_long (PyObject* obj, long* val)
2941 {
2942 if (PyNumber_Check(obj)) {
2943 if (val) *val = PyInt_AsLong(obj);
2944 return SWIG_OK;
2945 }
2946 return SWIG_TypeError;
2947 }
2948
2949
2950 SWIGINTERN int
2951 SWIG_AsVal_int (PyObject * obj, int *val)
2952 {
2953 long v;
2954 int res = SWIG_AsVal_long (obj, &v);
2955 if (SWIG_IsOK(res)) {
2956 if ((v < INT_MIN || v > INT_MAX)) {
2957 return SWIG_OverflowError;
2958 } else {
2959 if (val) *val = static_cast< int >(v);
2960 }
2961 }
2962 return res;
2963 }
2964
2965 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2966 wxSize temp, *obj = &temp;
2967 if ( other == Py_None ) return false;
2968 if ( ! wxSize_helper(other, &obj) ) {
2969 PyErr_Clear();
2970 return false;
2971 }
2972 return self->operator==(*obj);
2973 }
2974 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2975 wxSize temp, *obj = &temp;
2976 if ( other == Py_None ) return true;
2977 if ( ! wxSize_helper(other, &obj)) {
2978 PyErr_Clear();
2979 return true;
2980 }
2981 return self->operator!=(*obj);
2982 }
2983
2984 #include <float.h>
2985
2986
2987 SWIGINTERN int
2988 SWIG_AsVal_double (PyObject *obj, double* val)
2989 {
2990 if (PyNumber_Check(obj)) {
2991 if (val) *val = PyFloat_AsDouble(obj);
2992 return SWIG_OK;
2993 }
2994 return SWIG_TypeError;
2995 }
2996
2997
2998 SWIGINTERN int
2999 SWIG_AsVal_float (PyObject * obj, float *val)
3000 {
3001 double v;
3002 int res = SWIG_AsVal_double (obj, &v);
3003 if (SWIG_IsOK(res)) {
3004 if ((v < -FLT_MAX || v > FLT_MAX)) {
3005 return SWIG_OverflowError;
3006 } else {
3007 if (val) *val = static_cast< float >(v);
3008 }
3009 }
3010 return res;
3011 }
3012
3013 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3014 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3015 PyObject* tup = PyTuple_New(2);
3016 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3017 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3018 wxPyEndBlockThreads(blocked);
3019 return tup;
3020 }
3021
3022 #define SWIG_From_double PyFloat_FromDouble
3023
3024 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3025 wxRealPoint temp, *obj = &temp;
3026 if ( other == Py_None ) return false;
3027 if ( ! wxRealPoint_helper(other, &obj) ) {
3028 PyErr_Clear();
3029 return false;
3030 }
3031 return self->operator==(*obj);
3032 }
3033 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3034 wxRealPoint temp, *obj = &temp;
3035 if ( other == Py_None ) return true;
3036 if ( ! wxRealPoint_helper(other, &obj)) {
3037 PyErr_Clear();
3038 return true;
3039 }
3040 return self->operator!=(*obj);
3041 }
3042 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3043 self->x = x;
3044 self->y = y;
3045 }
3046 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3047 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3048 PyObject* tup = PyTuple_New(2);
3049 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3050 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3051 wxPyEndBlockThreads(blocked);
3052 return tup;
3053 }
3054 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3055 wxPoint temp, *obj = &temp;
3056 if ( other == Py_None ) return false;
3057 if ( ! wxPoint_helper(other, &obj) ) {
3058 PyErr_Clear();
3059 return false;
3060 }
3061 return self->operator==(*obj);
3062 }
3063 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3064 wxPoint temp, *obj = &temp;
3065 if ( other == Py_None ) return true;
3066 if ( ! wxPoint_helper(other, &obj)) {
3067 PyErr_Clear();
3068 return true;
3069 }
3070 return self->operator!=(*obj);
3071 }
3072 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3073 self->x = x;
3074 self->y = y;
3075 }
3076 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3078 PyObject* tup = PyTuple_New(2);
3079 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3080 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3081 wxPyEndBlockThreads(blocked);
3082 return tup;
3083 }
3084 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3085 wxRect temp, *obj = &temp;
3086 if ( other == Py_None ) return false;
3087 if ( ! wxRect_helper(other, &obj) ) {
3088 PyErr_Clear();
3089 return false;
3090 }
3091 return self->operator==(*obj);
3092 }
3093 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3094 wxRect temp, *obj = &temp;
3095 if ( other == Py_None ) return true;
3096 if ( ! wxRect_helper(other, &obj)) {
3097 PyErr_Clear();
3098 return true;
3099 }
3100 return self->operator!=(*obj);
3101 }
3102 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3103 self->x = x;
3104 self->y = y;
3105 self->width = width;
3106 self->height = height;
3107 }
3108 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3109 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3110 PyObject* tup = PyTuple_New(4);
3111 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3112 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3113 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3114 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3115 wxPyEndBlockThreads(blocked);
3116 return tup;
3117 }
3118
3119 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3120 wxRegion reg1(*r1);
3121 wxRegion reg2(*r2);
3122 wxRect dest(0,0,0,0);
3123 PyObject* obj;
3124
3125 reg1.Intersect(reg2);
3126 dest = reg1.GetBox();
3127
3128 if (dest != wxRect(0,0,0,0)) {
3129 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3130 wxRect* newRect = new wxRect(dest);
3131 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3132 wxPyEndBlockThreads(blocked);
3133 return obj;
3134 }
3135 Py_INCREF(Py_None);
3136 return Py_None;
3137 }
3138
3139 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3140 wxPoint2D temp, *obj = &temp;
3141 if ( other == Py_None ) return false;
3142 if ( ! wxPoint2D_helper(other, &obj) ) {
3143 PyErr_Clear();
3144 return false;
3145 }
3146 return self->operator==(*obj);
3147 }
3148 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3149 wxPoint2D temp, *obj = &temp;
3150 if ( other == Py_None ) return true;
3151 if ( ! wxPoint2D_helper(other, &obj)) {
3152 PyErr_Clear();
3153 return true;
3154 }
3155 return self->operator!=(*obj);
3156 }
3157 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3158 self->m_x = x;
3159 self->m_y = y;
3160 }
3161 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3162 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3163 PyObject* tup = PyTuple_New(2);
3164 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3165 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3166 wxPyEndBlockThreads(blocked);
3167 return tup;
3168 }
3169
3170 #include "wx/wxPython/pyistream.h"
3171
3172 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3173 wxInputStream* wxis = wxPyCBInputStream::create(p);
3174 if (wxis)
3175 return new wxPyInputStream(wxis);
3176 else
3177 return NULL;
3178 }
3179
3180 SWIGINTERN swig_type_info*
3181 SWIG_pchar_descriptor()
3182 {
3183 static int init = 0;
3184 static swig_type_info* info = 0;
3185 if (!init) {
3186 info = SWIG_TypeQuery("_p_char");
3187 init = 1;
3188 }
3189 return info;
3190 }
3191
3192
3193 SWIGINTERNINLINE PyObject *
3194 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3195 {
3196 if (carray) {
3197 if (size > INT_MAX) {
3198 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3199 return pchar_descriptor ?
3200 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3201 } else {
3202 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3203 }
3204 } else {
3205 return SWIG_Py_Void();
3206 }
3207 }
3208
3209
3210 SWIGINTERNINLINE PyObject *
3211 SWIG_From_char (char c)
3212 {
3213 return SWIG_FromCharPtrAndSize(&c,1);
3214 }
3215
3216
3217 SWIGINTERNINLINE PyObject*
3218 SWIG_From_unsigned_SS_long (unsigned long value)
3219 {
3220 return (value > LONG_MAX) ?
3221 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3222 }
3223
3224
3225 SWIGINTERNINLINE PyObject *
3226 SWIG_From_size_t (size_t value)
3227 {
3228 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3229 }
3230
3231
3232 SWIGINTERN int
3233 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3234 {
3235 if (PyString_Check(obj)) {
3236 char *cstr; Py_ssize_t len;
3237 PyString_AsStringAndSize(obj, &cstr, &len);
3238 if (cptr) {
3239 if (alloc) {
3240 /*
3241 In python the user should not be able to modify the inner
3242 string representation. To warranty that, if you define
3243 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3244 buffer is always returned.
3245
3246 The default behavior is just to return the pointer value,
3247 so, be careful.
3248 */
3249 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3250 if (*alloc != SWIG_OLDOBJ)
3251 #else
3252 if (*alloc == SWIG_NEWOBJ)
3253 #endif
3254 {
3255 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3256 *alloc = SWIG_NEWOBJ;
3257 }
3258 else {
3259 *cptr = cstr;
3260 *alloc = SWIG_OLDOBJ;
3261 }
3262 } else {
3263 *cptr = PyString_AsString(obj);
3264 }
3265 }
3266 if (psize) *psize = len + 1;
3267 return SWIG_OK;
3268 } else {
3269 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3270 if (pchar_descriptor) {
3271 void* vptr = 0;
3272 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3273 if (cptr) *cptr = (char *) vptr;
3274 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3275 if (alloc) *alloc = SWIG_OLDOBJ;
3276 return SWIG_OK;
3277 }
3278 }
3279 }
3280 return SWIG_TypeError;
3281 }
3282
3283
3284 SWIGINTERN int
3285 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3286 {
3287 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3288 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3289 if (SWIG_IsOK(res)) {
3290 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3291 if (csize <= size) {
3292 if (val) {
3293 if (csize) memcpy(val, cptr, csize*sizeof(char));
3294 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3295 }
3296 if (alloc == SWIG_NEWOBJ) {
3297 delete[] cptr;
3298 res = SWIG_DelNewMask(res);
3299 }
3300 return res;
3301 }
3302 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3303 }
3304 return SWIG_TypeError;
3305 }
3306
3307
3308 SWIGINTERN int
3309 SWIG_AsVal_char (PyObject * obj, char *val)
3310 {
3311 int res = SWIG_AsCharArray(obj, val, 1);
3312 if (!SWIG_IsOK(res)) {
3313 long v;
3314 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3315 if (SWIG_IsOK(res)) {
3316 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3317 if (val) *val = static_cast< char >(v);
3318 } else {
3319 res = SWIG_OverflowError;
3320 }
3321 }
3322 }
3323 return res;
3324 }
3325
3326 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3327 // We use only strings for the streams, not unicode
3328 PyObject* str = PyObject_Str(obj);
3329 if (! str) {
3330 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3331 return;
3332 }
3333 self->Write(PyString_AS_STRING(str),
3334 PyString_GET_SIZE(str));
3335 Py_DECREF(str);
3336 }
3337
3338 #include "wx/wxPython/pyistream.h"
3339
3340
3341 class wxPyFileSystemHandler : public wxFileSystemHandler
3342 {
3343 public:
3344 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3345
3346 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3347 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3348 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3349 DEC_PYCALLBACK_STRING__pure(FindNext);
3350
3351 wxString GetProtocol(const wxString& location) {
3352 return wxFileSystemHandler::GetProtocol(location);
3353 }
3354
3355 wxString GetLeftLocation(const wxString& location) {
3356 return wxFileSystemHandler::GetLeftLocation(location);
3357 }
3358
3359 wxString GetAnchor(const wxString& location) {
3360 return wxFileSystemHandler::GetAnchor(location);
3361 }
3362
3363 wxString GetRightLocation(const wxString& location) {
3364 return wxFileSystemHandler::GetRightLocation(location);
3365 }
3366
3367 wxString GetMimeTypeFromExt(const wxString& location) {
3368 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3369 }
3370
3371 PYPRIVATE;
3372 };
3373
3374
3375 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3376 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3377 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3378 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3379
3380
3381 SWIGINTERN int
3382 SWIG_AsVal_bool (PyObject *obj, bool *val)
3383 {
3384 if (obj == Py_True) {
3385 if (val) *val = true;
3386 return SWIG_OK;
3387 } else if (obj == Py_False) {
3388 if (val) *val = false;
3389 return SWIG_OK;
3390 } else {
3391 long v = 0;
3392 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3393 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3394 return res;
3395 }
3396 }
3397
3398 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3399 wxFileName fname = wxFileSystem::URLToFileName(url);
3400 return fname.GetFullPath();
3401 }
3402
3403 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3404 wxImage& image,
3405 long type) {
3406 wxMemoryFSHandler::AddFile(filename, image, type);
3407 }
3408
3409 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3410 const wxBitmap& bitmap,
3411 long type) {
3412 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3413 }
3414
3415 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3416 PyObject* data) {
3417 if (! PyString_Check(data)) {
3418 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3419 "Expected string object"));
3420 return;
3421 }
3422
3423 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3424 void* ptr = (void*)PyString_AsString(data);
3425 size_t size = PyString_Size(data);
3426 wxPyEndBlockThreads(blocked);
3427
3428 wxMemoryFSHandler::AddFile(filename, ptr, size);
3429 }
3430
3431
3432 #include "wx/wxPython/pyistream.h"
3433
3434
3435 SWIGINTERN int
3436 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3437 {
3438 long v = 0;
3439 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3440 return SWIG_TypeError;
3441 }
3442 else if (val)
3443 *val = (unsigned long)v;
3444 return SWIG_OK;
3445 }
3446
3447
3448 SWIGINTERN int
3449 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3450 {
3451 unsigned long v;
3452 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3453 if (SWIG_IsOK(res)) {
3454 if ((v > UCHAR_MAX)) {
3455 return SWIG_OverflowError;
3456 } else {
3457 if (val) *val = static_cast< unsigned char >(v);
3458 }
3459 }
3460 return res;
3461 }
3462
3463
3464 SWIGINTERNINLINE PyObject *
3465 SWIG_From_unsigned_SS_char (unsigned char value)
3466 {
3467 return SWIG_From_unsigned_SS_long (value);
3468 }
3469
3470 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3471 wxImageHistogramEntry e = (*self)[key];
3472 return e.value;
3473 }
3474 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3475 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3476 wxImageHistogramEntry e = (*self)[key];
3477 return e.value;
3478 }
3479 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3480 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3481 colour.Green(),
3482 colour.Blue());
3483 wxImageHistogramEntry e = (*self)[key];
3484 return e.value;
3485 }
3486
3487 // Pull the nested class out to the top level for SWIG's sake
3488 #define wxImage_RGBValue wxImage::RGBValue
3489 #define wxImage_HSVValue wxImage::HSVValue
3490
3491 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3492 if (width > 0 && height > 0)
3493 return new wxImage(width, height, clear);
3494 else
3495 return new wxImage;
3496 }
3497 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3498 return new wxImage(bitmap.ConvertToImage());
3499 }
3500 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3501 if (DATASIZE != width*height*3) {
3502 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3503 return NULL;
3504 }
3505
3506 // Copy the source data so the wxImage can clean it up later
3507 buffer copy = (buffer)malloc(DATASIZE);
3508 if (copy == NULL) {
3509 wxPyBLOCK_THREADS(PyErr_NoMemory());
3510 return NULL;
3511 }
3512 memcpy(copy, data, DATASIZE);
3513 return new wxImage(width, height, copy, false);
3514 }
3515 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3516 if (DATASIZE != width*height*3) {
3517 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3518 return NULL;
3519 }
3520 if (ALPHASIZE != width*height) {
3521 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3522 return NULL;
3523 }
3524
3525 // Copy the source data so the wxImage can clean it up later
3526 buffer dcopy = (buffer)malloc(DATASIZE);
3527 if (dcopy == NULL) {
3528 wxPyBLOCK_THREADS(PyErr_NoMemory());
3529 return NULL;
3530 }
3531 memcpy(dcopy, data, DATASIZE);
3532
3533 buffer acopy = (buffer)malloc(ALPHASIZE);
3534 if (acopy == NULL) {
3535 wxPyBLOCK_THREADS(PyErr_NoMemory());
3536 return NULL;
3537 }
3538 memcpy(acopy, alpha, ALPHASIZE);
3539
3540 return new wxImage(width, height, dcopy, acopy, false);
3541 }
3542 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3543 wxSize size(self->GetWidth(), self->GetHeight());
3544 return size;
3545 }
3546 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3547 buffer data = self->GetData();
3548 int len = self->GetWidth() * self->GetHeight() * 3;
3549 PyObject* rv;
3550 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3551 return rv;
3552 }
3553 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3554 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3555 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3556 return;
3557 }
3558 buffer copy = (buffer)malloc(DATASIZE);
3559 if (copy == NULL) {
3560 wxPyBLOCK_THREADS(PyErr_NoMemory());
3561 return;
3562 }
3563 memcpy(copy, data, DATASIZE);
3564 self->SetData(copy, false);
3565 // wxImage takes ownership of copy...
3566 }
3567 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3568 buffer data = self->GetData();
3569 int len = self->GetWidth() * self->GetHeight() * 3;
3570 PyObject* rv;
3571 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3572 return rv;
3573 }
3574 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3575 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3576 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3577 return;
3578 }
3579 self->SetData(data, true);
3580 }
3581 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3582 buffer data = self->GetAlpha();
3583 if (! data) {
3584 RETURN_NONE();
3585 } else {
3586 int len = self->GetWidth() * self->GetHeight();
3587 PyObject* rv;
3588 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3589 return rv;
3590 }
3591 }
3592 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3593 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3594 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3595 return;
3596 }
3597 buffer acopy = (buffer)malloc(ALPHASIZE);
3598 if (acopy == NULL) {
3599 wxPyBLOCK_THREADS(PyErr_NoMemory());
3600 return;
3601 }
3602 memcpy(acopy, alpha, ALPHASIZE);
3603 self->SetAlpha(acopy, false);
3604 // wxImage takes ownership of acopy...
3605 }
3606 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3607 buffer data = self->GetAlpha();
3608 int len = self->GetWidth() * self->GetHeight();
3609 PyObject* rv;
3610 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3611 return rv;
3612 }
3613 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3614 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3615 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3616 return;
3617 }
3618 self->SetAlpha(alpha, true);
3619 }
3620 SWIGINTERN PyObject *wxImage_GetHandlers(){
3621 wxList& list = wxImage::GetHandlers();
3622 return wxPy_ConvertList(&list);
3623 }
3624 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3625 wxBitmap bitmap(*self, depth);
3626 return bitmap;
3627 }
3628 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3629 wxImage mono = self->ConvertToMono( red, green, blue );
3630 wxBitmap bitmap( mono, 1 );
3631 return bitmap;
3632 }
3633
3634 wxImage* _ImageFromBuffer(int width, int height,
3635 buffer data, int DATASIZE,
3636 buffer alpha=NULL, int ALPHASIZE=0)
3637 {
3638 if (DATASIZE != width*height*3) {
3639 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3640 return NULL;
3641 }
3642 if (alpha != NULL) {
3643 if (ALPHASIZE != width*height) {
3644 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3645 return NULL;
3646 }
3647 return new wxImage(width, height, data, alpha, true);
3648 }
3649 return new wxImage(width, height, data, true);
3650 }
3651
3652 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3653 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3654 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3655 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3656 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3657 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3658 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3659 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3660 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3661 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3662 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3663 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3664 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3665 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3666 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3667
3668 #include <wx/quantize.h>
3669
3670 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3671 return wxQuantize::Quantize(src, dest,
3672 //NULL, // palette
3673 desiredNoColours,
3674 NULL, // eightBitData
3675 flags);
3676 }
3677 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3678 if (PyCallable_Check(func)) {
3679 self->Connect(id, lastId, eventType,
3680 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3681 new wxPyCallback(func));
3682 }
3683 else if (func == Py_None) {
3684 self->Disconnect(id, lastId, eventType,
3685 (wxObjectEventFunction)
3686 &wxPyCallback::EventThunker);
3687 }
3688 else {
3689 wxPyBLOCK_THREADS(
3690 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3691 }
3692 }
3693 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3694 return self->Disconnect(id, lastId, eventType,
3695 (wxObjectEventFunction)
3696 &wxPyCallback::EventThunker);
3697 }
3698 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3699 if (_self && _self != Py_None) {
3700 self->SetClientObject(new wxPyOORClientData(_self, incref));
3701 }
3702 else {
3703 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3704 if (data) {
3705 self->SetClientObject(NULL); // This will delete it too
3706 }
3707 }
3708 }
3709
3710 #if ! wxUSE_HOTKEY
3711 #define wxEVT_HOTKEY -9999
3712 #endif
3713
3714 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3715 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3716 if (data) {
3717 Py_INCREF(data->m_obj);
3718 return data->m_obj;
3719 } else {
3720 Py_INCREF(Py_None);
3721 return Py_None;
3722 }
3723 }
3724 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3725 wxPyClientData* data = new wxPyClientData(clientData);
3726 self->SetClientObject(data);
3727 }
3728 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3729 #if wxUSE_UNICODE
3730 return self->GetUnicodeKey();
3731 #else
3732 return 0;
3733 #endif
3734 }
3735 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3736 #if wxUSE_UNICODE
3737 self->m_uniChar = uniChar;
3738 #endif
3739 }
3740
3741 SWIGINTERNINLINE PyObject *
3742 SWIG_From_unsigned_SS_int (unsigned int value)
3743 {
3744 return SWIG_From_unsigned_SS_long (value);
3745 }
3746
3747
3748 SWIGINTERN int
3749 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3750 {
3751 unsigned long v;
3752 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3753 if (SWIG_IsOK(res)) {
3754 if ((v > UINT_MAX)) {
3755 return SWIG_OverflowError;
3756 } else {
3757 if (val) *val = static_cast< unsigned int >(v);
3758 }
3759 }
3760 return res;
3761 }
3762
3763 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3764 self->m_size = size;
3765 }
3766 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3767 int count = self->GetNumberOfFiles();
3768 wxString* files = self->GetFiles();
3769 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3770 PyObject* list = PyList_New(count);
3771
3772 if (!list) {
3773 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3774 wxPyEndBlockThreads(blocked);
3775 return NULL;
3776 }
3777
3778 for (int i=0; i<count; i++) {
3779 PyList_SetItem(list, i, wx2PyString(files[i]));
3780 }
3781 wxPyEndBlockThreads(blocked);
3782 return list;
3783 }
3784
3785
3786 SWIGINTERN wxPyApp *new_wxPyApp(){
3787 wxPythonApp = new wxPyApp();
3788 return wxPythonApp;
3789 }
3790 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3791 SWIGINTERN bool wxPyApp_DisplayAvailable(){
3792 return wxPyTestDisplayAvailable();
3793 }
3794
3795 void wxApp_CleanUp() {
3796 __wxPyCleanup();
3797 }
3798
3799
3800 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3801
3802
3803
3804
3805
3806 SWIGINTERNINLINE PyObject *
3807 SWIG_FromCharPtr(const char *cptr)
3808 {
3809 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3810 }
3811
3812
3813 #if 0 // #ifdef __WXMAC__
3814
3815 // A dummy class that raises an exception if used...
3816 class wxEventLoop
3817 {
3818 public:
3819 wxEventLoop() { wxPyRaiseNotImplemented(); }
3820 int Run() { return 0; }
3821 void Exit(int rc = 0) {}
3822 bool Pending() const { return false; }
3823 bool Dispatch() { return false; }
3824 bool IsRunning() const { return false; }
3825 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3826 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3827 };
3828
3829 #else
3830
3831 #include <wx/evtloop.h>
3832
3833 #endif
3834
3835
3836
3837 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3838 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3839 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3840 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3841 wxWindowList& list = self->GetChildren();
3842 return wxPy_ConvertList(&list);
3843 }
3844 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3845 #if wxUSE_HOTKEY
3846 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3847 #else
3848 return false;
3849 #endif
3850 }
3851 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3852
3853
3854
3855 return false;
3856
3857 }
3858 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3859 return wxPyGetWinHandle(self);
3860 }
3861 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3862 self->AssociateHandle((WXWidget)handle);
3863 }
3864 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3865
3866 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3867 return wxWindow::FindWindowById(id, parent);
3868 }
3869
3870 wxWindow* wxFindWindowByName( const wxString& name,
3871 const wxWindow *parent = NULL ) {
3872 return wxWindow::FindWindowByName(name, parent);
3873 }
3874
3875 wxWindow* wxFindWindowByLabel( const wxString& label,
3876 const wxWindow *parent = NULL ) {
3877 return wxWindow::FindWindowByLabel(label, parent);
3878 }
3879
3880
3881 #ifdef __WXMSW__
3882 #include <wx/msw/private.h> // to get wxGetWindowId
3883 #endif
3884
3885
3886 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3887 #ifdef __WXMSW__
3888 WXHWND hWnd = (WXHWND)_hWnd;
3889 long id = wxGetWindowId(hWnd);
3890 wxWindow* win = new wxWindow;
3891 if (parent)
3892 parent->AddChild(win);
3893 win->SetEventHandler(win);
3894 win->SetHWND(hWnd);
3895 win->SetId(id);
3896 win->SubclassWin(hWnd);
3897 win->AdoptAttributesFromHWND();
3898 win->SetupColours();
3899 return win;
3900 #else
3901 wxPyRaiseNotImplemented();
3902 return NULL;
3903 #endif
3904 }
3905
3906
3907 PyObject* GetTopLevelWindows() {
3908 return wxPy_ConvertList(&wxTopLevelWindows);
3909 }
3910
3911
3912 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3913 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3914 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3915
3916 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3917
3918
3919 SWIGINTERNINLINE int
3920 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3921 {
3922 unsigned long v;
3923 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3924 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3925 return res;
3926 }
3927
3928 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3929 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3930 wxMenuItemList& list = self->GetMenuItems();
3931 return wxPy_ConvertList(&list);
3932 }
3933 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3934 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3935 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3936 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3937 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3938 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3939 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3940 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3941 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3942 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3943 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3944 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3945 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3946 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3947 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3948 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3949 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3950 static const wxString wxPyControlNameStr(wxControlNameStr);
3951 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3952 if (clientData) {
3953 wxPyClientData* data = new wxPyClientData(clientData);
3954 return self->Append(item, data);
3955 } else
3956 return self->Append(item);
3957 }
3958 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3959 if (clientData) {
3960 wxPyClientData* data = new wxPyClientData(clientData);
3961 return self->Insert(item, pos, data);
3962 } else
3963 return self->Insert(item, pos);
3964 }
3965 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3966 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3967 if (data) {
3968 Py_INCREF(data->m_obj);
3969 return data->m_obj;
3970 } else {
3971 Py_INCREF(Py_None);
3972 return Py_None;
3973 }
3974 }
3975 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3976 wxPyClientData* data = new wxPyClientData(clientData);
3977 self->SetClientObject(n, data);
3978 }
3979
3980
3981 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3982 wxPyUserData* data = NULL;
3983 if ( userData ) {
3984 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3985 data = new wxPyUserData(userData);
3986 wxPyEndBlockThreads(blocked);
3987 }
3988 return new wxSizerItem(window, proportion, flag, border, data);
3989 }
3990 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3991 wxPyUserData* data = NULL;
3992 if ( userData ) {
3993 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3994 data = new wxPyUserData(userData);
3995 wxPyEndBlockThreads(blocked);
3996 }
3997 return new wxSizerItem(width, height, proportion, flag, border, data);
3998 }
3999 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4000 wxPyUserData* data = NULL;
4001 if ( userData ) {
4002 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4003 data = new wxPyUserData(userData);
4004 wxPyEndBlockThreads(blocked);
4005 }
4006 return new wxSizerItem(sizer, proportion, flag, border, data);
4007 }
4008
4009 SWIGINTERNINLINE PyObject *
4010 SWIG_From_float (float value)
4011 {
4012 return SWIG_From_double (value);
4013 }
4014
4015 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4016 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4017 if (data) {
4018 Py_INCREF(data->m_obj);
4019 return data->m_obj;
4020 } else {
4021 Py_INCREF(Py_None);
4022 return Py_None;
4023 }
4024 }
4025 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4026 wxPyUserData* data = NULL;
4027 if ( userData ) {
4028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4029 data = new wxPyUserData(userData);
4030 wxPyEndBlockThreads(blocked);
4031 }
4032 self->SetUserData(data);
4033 }
4034
4035 // Figure out the type of the sizer item
4036
4037 struct wxPySizerItemInfo {
4038 wxPySizerItemInfo()
4039 : window(NULL), sizer(NULL), gotSize(false),
4040 size(wxDefaultSize), gotPos(false), pos(-1)
4041 {}
4042
4043 wxWindow* window;
4044 wxSizer* sizer;
4045 bool gotSize;
4046 wxSize size;
4047 bool gotPos;
4048 int pos;
4049 };
4050
4051 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4052
4053 wxPySizerItemInfo info;
4054 wxSize size;
4055 wxSize* sizePtr = &size;
4056
4057 // Find out what the type of the item is
4058 // try wxWindow
4059 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4060 PyErr_Clear();
4061 info.window = NULL;
4062
4063 // try wxSizer
4064 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4065 PyErr_Clear();
4066 info.sizer = NULL;
4067
4068 // try wxSize or (w,h)
4069 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4070 info.size = *sizePtr;
4071 info.gotSize = true;
4072 }
4073
4074 // or a single int
4075 if (checkIdx && PyInt_Check(item)) {
4076 info.pos = PyInt_AsLong(item);
4077 info.gotPos = true;
4078 }
4079 }
4080 }
4081
4082 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4083 // no expected type, figure out what kind of error message to generate
4084 if ( !checkSize && !checkIdx )
4085 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4086 else if ( checkSize && !checkIdx )
4087 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4088 else if ( !checkSize && checkIdx)
4089 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4090 else
4091 // can this one happen?
4092 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4093 }
4094
4095 return info;
4096 }
4097
4098 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4099 if (!self->GetClientObject())
4100 self->SetClientObject(new wxPyOORClientData(_self));
4101 }
4102 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4103
4104 wxPyUserData* data = NULL;
4105 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4106 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4107 if ( userData && (info.window || info.sizer || info.gotSize) )
4108 data = new wxPyUserData(userData);
4109 if ( info.sizer )
4110 PyObject_SetAttrString(item,"thisown",Py_False);
4111 wxPyEndBlockThreads(blocked);
4112
4113 // Now call the real Add method if a valid item type was found
4114 if ( info.window )
4115 return self->Add(info.window, proportion, flag, border, data);
4116 else if ( info.sizer )
4117 return self->Add(info.sizer, proportion, flag, border, data);
4118 else if (info.gotSize)
4119 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4120 proportion, flag, border, data);
4121 else
4122 return NULL;
4123 }
4124 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4125
4126 wxPyUserData* data = NULL;
4127 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4128 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4129 if ( userData && (info.window || info.sizer || info.gotSize) )
4130 data = new wxPyUserData(userData);
4131 if ( info.sizer )
4132 PyObject_SetAttrString(item,"thisown",Py_False);
4133 wxPyEndBlockThreads(blocked);
4134
4135 // Now call the real Insert method if a valid item type was found
4136 if ( info.window )
4137 return self->Insert(before, info.window, proportion, flag, border, data);
4138 else if ( info.sizer )
4139 return self->Insert(before, info.sizer, proportion, flag, border, data);
4140 else if (info.gotSize)
4141 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4142 proportion, flag, border, data);
4143 else
4144 return NULL;
4145 }
4146 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4147
4148 wxPyUserData* data = NULL;
4149 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4150 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4151 if ( userData && (info.window || info.sizer || info.gotSize) )
4152 data = new wxPyUserData(userData);
4153 if ( info.sizer )
4154 PyObject_SetAttrString(item,"thisown",Py_False);
4155 wxPyEndBlockThreads(blocked);
4156
4157 // Now call the real Prepend method if a valid item type was found
4158 if ( info.window )
4159 return self->Prepend(info.window, proportion, flag, border, data);
4160 else if ( info.sizer )
4161 return self->Prepend(info.sizer, proportion, flag, border, data);
4162 else if (info.gotSize)
4163 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4164 proportion, flag, border, data);
4165 else
4166 return NULL;
4167 }
4168 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4169 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4170 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4171 wxPyEndBlockThreads(blocked);
4172 if ( info.window )
4173 return self->Remove(info.window);
4174 else if ( info.sizer )
4175 return self->Remove(info.sizer);
4176 else if ( info.gotPos )
4177 return self->Remove(info.pos);
4178 else
4179 return false;
4180 }
4181 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4183 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4184 wxPyEndBlockThreads(blocked);
4185 if ( info.window )
4186 return self->Detach(info.window);
4187 else if ( info.sizer )
4188 return self->Detach(info.sizer);
4189 else if ( info.gotPos )
4190 return self->Detach(info.pos);
4191 else
4192 return false;
4193 }
4194 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4195 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4196 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4197 wxPyEndBlockThreads(blocked);
4198 if ( info.window )
4199 return self->GetItem(info.window);
4200 else if ( info.sizer )
4201 return self->GetItem(info.sizer);
4202 else if ( info.gotPos )
4203 return self->GetItem(info.pos);
4204 else
4205 return NULL;
4206 }
4207 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4208 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4209 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4210 wxPyEndBlockThreads(blocked);
4211 if ( info.window )
4212 self->SetItemMinSize(info.window, size);
4213 else if ( info.sizer )
4214 self->SetItemMinSize(info.sizer, size);
4215 else if ( info.gotPos )
4216 self->SetItemMinSize(info.pos, size);
4217 }
4218 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4219 wxSizerItemList& list = self->GetChildren();
4220 return wxPy_ConvertList(&list);
4221 }
4222 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4224 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4225 wxPyEndBlockThreads(blocked);
4226 if ( info.window )
4227 return self->Show(info.window, show, recursive);
4228 else if ( info.sizer )
4229 return self->Show(info.sizer, show, recursive);
4230 else if ( info.gotPos )
4231 return self->Show(info.pos, show);
4232 else
4233 return false;
4234 }
4235 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4236 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4237 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4238 wxPyEndBlockThreads(blocked);
4239 if ( info.window )
4240 return self->IsShown(info.window);
4241 else if ( info.sizer )
4242 return self->IsShown(info.sizer);
4243 else if ( info.gotPos )
4244 return self->IsShown(info.pos);
4245 else
4246 return false;
4247 }
4248
4249 // See pyclasses.h
4250 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4251 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4252 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4253
4254
4255
4256
4257 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4258 {
4259 if (source == Py_None) {
4260 **obj = wxGBPosition(-1,-1);
4261 return true;
4262 }
4263 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4264 }
4265
4266 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4267 {
4268 if (source == Py_None) {
4269 **obj = wxGBSpan(-1,-1);
4270 return true;
4271 }
4272 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4273 }
4274
4275
4276 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4277 wxGBPosition temp, *obj = &temp;
4278 if ( other == Py_None ) return false;
4279 if ( ! wxGBPosition_helper(other, &obj) ) {
4280 PyErr_Clear();
4281 return false;
4282 }
4283 return self->operator==(*obj);
4284 }
4285 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4286 wxGBPosition temp, *obj = &temp;
4287 if ( other == Py_None ) return true;
4288 if ( ! wxGBPosition_helper(other, &obj)) {
4289 PyErr_Clear();
4290 return true;
4291 }
4292 return self->operator!=(*obj);
4293 }
4294 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4295 self->SetRow(row);
4296 self->SetCol(col);
4297 }
4298 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4299 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4300 PyObject* tup = PyTuple_New(2);
4301 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4302 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4303 wxPyEndBlockThreads(blocked);
4304 return tup;
4305 }
4306 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4307 wxGBSpan temp, *obj = &temp;
4308 if ( other == Py_None ) return false;
4309 if ( ! wxGBSpan_helper(other, &obj) ) {
4310 PyErr_Clear();
4311 return false;
4312 }
4313 return self->operator==(*obj);
4314 }
4315 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4316 wxGBSpan temp, *obj = &temp;
4317 if ( other == Py_None ) return true;
4318 if ( ! wxGBSpan_helper(other, &obj)) {
4319 PyErr_Clear();
4320 return true;
4321 }
4322 return self->operator!=(*obj);
4323 }
4324 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4325 self->SetRowspan(rowspan);
4326 self->SetColspan(colspan);
4327 }
4328 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4329 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4330 PyObject* tup = PyTuple_New(2);
4331 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4332 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4333 wxPyEndBlockThreads(blocked);
4334 return tup;
4335 }
4336 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4337 wxPyUserData* data = NULL;
4338 if ( userData ) {
4339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4340 data = new wxPyUserData(userData);
4341 wxPyEndBlockThreads(blocked);
4342 }
4343 return new wxGBSizerItem(window, pos, span, flag, border, data);
4344 }
4345 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4346 wxPyUserData* data = NULL;
4347 if ( userData ) {
4348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4349 data = new wxPyUserData(userData);
4350 wxPyEndBlockThreads(blocked);
4351 }
4352 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4353 }
4354 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4355 wxPyUserData* data = NULL;
4356 if ( userData ) {
4357 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4358 data = new wxPyUserData(userData);
4359 wxPyEndBlockThreads(blocked);
4360 }
4361 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4362 }
4363 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4364 int row, col;
4365 self->GetEndPos(row, col);
4366 return wxGBPosition(row, col);
4367 }
4368 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4369
4370 wxPyUserData* data = NULL;
4371 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4372 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4373 if ( userData && (info.window || info.sizer || info.gotSize) )
4374 data = new wxPyUserData(userData);
4375 if ( info.sizer )
4376 PyObject_SetAttrString(item,"thisown",Py_False);
4377 wxPyEndBlockThreads(blocked);
4378
4379 // Now call the real Add method if a valid item type was found
4380 if ( info.window )
4381 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4382 else if ( info.sizer )
4383 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4384 else if (info.gotSize)
4385 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4386 pos, span, flag, border, data);
4387 return NULL;
4388 }
4389
4390
4391 #ifdef __cplusplus
4392 extern "C" {
4393 #endif
4394 SWIGINTERN int EmptyString_set(PyObject *) {
4395 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4396 return 1;
4397 }
4398
4399
4400 SWIGINTERN PyObject *EmptyString_get(void) {
4401 PyObject *pyobj = 0;
4402
4403 {
4404 #if wxUSE_UNICODE
4405 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4406 #else
4407 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4408 #endif
4409 }
4410 return pyobj;
4411 }
4412
4413
4414 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4415 PyObject *resultobj = 0;
4416 wxObject *arg1 = (wxObject *) 0 ;
4417 wxString result;
4418 void *argp1 = 0 ;
4419 int res1 = 0 ;
4420 PyObject *swig_obj[1] ;
4421
4422 if (!args) SWIG_fail;
4423 swig_obj[0] = args;
4424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4425 if (!SWIG_IsOK(res1)) {
4426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4427 }
4428 arg1 = reinterpret_cast< wxObject * >(argp1);
4429 {
4430 PyThreadState* __tstate = wxPyBeginAllowThreads();
4431 result = wxObject_GetClassName(arg1);
4432 wxPyEndAllowThreads(__tstate);
4433 if (PyErr_Occurred()) SWIG_fail;
4434 }
4435 {
4436 #if wxUSE_UNICODE
4437 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4438 #else
4439 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4440 #endif
4441 }
4442 return resultobj;
4443 fail:
4444 return NULL;
4445 }
4446
4447
4448 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4449 PyObject *resultobj = 0;
4450 wxObject *arg1 = (wxObject *) 0 ;
4451 void *argp1 = 0 ;
4452 int res1 = 0 ;
4453 PyObject *swig_obj[1] ;
4454
4455 if (!args) SWIG_fail;
4456 swig_obj[0] = args;
4457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4458 if (!SWIG_IsOK(res1)) {
4459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4460 }
4461 arg1 = reinterpret_cast< wxObject * >(argp1);
4462 {
4463 PyThreadState* __tstate = wxPyBeginAllowThreads();
4464 wxObject_Destroy(arg1);
4465 wxPyEndAllowThreads(__tstate);
4466 if (PyErr_Occurred()) SWIG_fail;
4467 }
4468 resultobj = SWIG_Py_Void();
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476 PyObject *obj;
4477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4478 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4479 return SWIG_Py_Void();
4480 }
4481
4482 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4483 PyObject *resultobj = 0;
4484 wxSize *arg1 = (wxSize *) 0 ;
4485 int arg2 ;
4486 void *argp1 = 0 ;
4487 int res1 = 0 ;
4488 int val2 ;
4489 int ecode2 = 0 ;
4490 PyObject *swig_obj[2] ;
4491
4492 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4494 if (!SWIG_IsOK(res1)) {
4495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4496 }
4497 arg1 = reinterpret_cast< wxSize * >(argp1);
4498 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4499 if (!SWIG_IsOK(ecode2)) {
4500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4501 }
4502 arg2 = static_cast< int >(val2);
4503 if (arg1) (arg1)->x = arg2;
4504
4505 resultobj = SWIG_Py_Void();
4506 return resultobj;
4507 fail:
4508 return NULL;
4509 }
4510
4511
4512 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4513 PyObject *resultobj = 0;
4514 wxSize *arg1 = (wxSize *) 0 ;
4515 int result;
4516 void *argp1 = 0 ;
4517 int res1 = 0 ;
4518 PyObject *swig_obj[1] ;
4519
4520 if (!args) SWIG_fail;
4521 swig_obj[0] = args;
4522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4523 if (!SWIG_IsOK(res1)) {
4524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4525 }
4526 arg1 = reinterpret_cast< wxSize * >(argp1);
4527 result = (int) ((arg1)->x);
4528 resultobj = SWIG_From_int(static_cast< int >(result));
4529 return resultobj;
4530 fail:
4531 return NULL;
4532 }
4533
4534
4535 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4536 PyObject *resultobj = 0;
4537 wxSize *arg1 = (wxSize *) 0 ;
4538 int arg2 ;
4539 void *argp1 = 0 ;
4540 int res1 = 0 ;
4541 int val2 ;
4542 int ecode2 = 0 ;
4543 PyObject *swig_obj[2] ;
4544
4545 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4547 if (!SWIG_IsOK(res1)) {
4548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4549 }
4550 arg1 = reinterpret_cast< wxSize * >(argp1);
4551 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4552 if (!SWIG_IsOK(ecode2)) {
4553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4554 }
4555 arg2 = static_cast< int >(val2);
4556 if (arg1) (arg1)->y = arg2;
4557
4558 resultobj = SWIG_Py_Void();
4559 return resultobj;
4560 fail:
4561 return NULL;
4562 }
4563
4564
4565 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4566 PyObject *resultobj = 0;
4567 wxSize *arg1 = (wxSize *) 0 ;
4568 int result;
4569 void *argp1 = 0 ;
4570 int res1 = 0 ;
4571 PyObject *swig_obj[1] ;
4572
4573 if (!args) SWIG_fail;
4574 swig_obj[0] = args;
4575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4576 if (!SWIG_IsOK(res1)) {
4577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4578 }
4579 arg1 = reinterpret_cast< wxSize * >(argp1);
4580 result = (int) ((arg1)->y);
4581 resultobj = SWIG_From_int(static_cast< int >(result));
4582 return resultobj;
4583 fail:
4584 return NULL;
4585 }
4586
4587
4588 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4589 PyObject *resultobj = 0;
4590 int arg1 = (int) 0 ;
4591 int arg2 = (int) 0 ;
4592 wxSize *result = 0 ;
4593 int val1 ;
4594 int ecode1 = 0 ;
4595 int val2 ;
4596 int ecode2 = 0 ;
4597 PyObject * obj0 = 0 ;
4598 PyObject * obj1 = 0 ;
4599 char * kwnames[] = {
4600 (char *) "w",(char *) "h", NULL
4601 };
4602
4603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4604 if (obj0) {
4605 ecode1 = SWIG_AsVal_int(obj0, &val1);
4606 if (!SWIG_IsOK(ecode1)) {
4607 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4608 }
4609 arg1 = static_cast< int >(val1);
4610 }
4611 if (obj1) {
4612 ecode2 = SWIG_AsVal_int(obj1, &val2);
4613 if (!SWIG_IsOK(ecode2)) {
4614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4615 }
4616 arg2 = static_cast< int >(val2);
4617 }
4618 {
4619 PyThreadState* __tstate = wxPyBeginAllowThreads();
4620 result = (wxSize *)new wxSize(arg1,arg2);
4621 wxPyEndAllowThreads(__tstate);
4622 if (PyErr_Occurred()) SWIG_fail;
4623 }
4624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4625 return resultobj;
4626 fail:
4627 return NULL;
4628 }
4629
4630
4631 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4632 PyObject *resultobj = 0;
4633 wxSize *arg1 = (wxSize *) 0 ;
4634 void *argp1 = 0 ;
4635 int res1 = 0 ;
4636 PyObject *swig_obj[1] ;
4637
4638 if (!args) SWIG_fail;
4639 swig_obj[0] = args;
4640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4641 if (!SWIG_IsOK(res1)) {
4642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4643 }
4644 arg1 = reinterpret_cast< wxSize * >(argp1);
4645 {
4646 PyThreadState* __tstate = wxPyBeginAllowThreads();
4647 delete arg1;
4648
4649 wxPyEndAllowThreads(__tstate);
4650 if (PyErr_Occurred()) SWIG_fail;
4651 }
4652 resultobj = SWIG_Py_Void();
4653 return resultobj;
4654 fail:
4655 return NULL;
4656 }
4657
4658
4659 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj = 0;
4661 wxSize *arg1 = (wxSize *) 0 ;
4662 PyObject *arg2 = (PyObject *) 0 ;
4663 bool result;
4664 void *argp1 = 0 ;
4665 int res1 = 0 ;
4666 PyObject * obj0 = 0 ;
4667 PyObject * obj1 = 0 ;
4668 char * kwnames[] = {
4669 (char *) "self",(char *) "other", NULL
4670 };
4671
4672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4674 if (!SWIG_IsOK(res1)) {
4675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4676 }
4677 arg1 = reinterpret_cast< wxSize * >(argp1);
4678 arg2 = obj1;
4679 {
4680 result = (bool)wxSize___eq__(arg1,arg2);
4681 if (PyErr_Occurred()) SWIG_fail;
4682 }
4683 {
4684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4685 }
4686 return resultobj;
4687 fail:
4688 return NULL;
4689 }
4690
4691
4692 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4693 PyObject *resultobj = 0;
4694 wxSize *arg1 = (wxSize *) 0 ;
4695 PyObject *arg2 = (PyObject *) 0 ;
4696 bool result;
4697 void *argp1 = 0 ;
4698 int res1 = 0 ;
4699 PyObject * obj0 = 0 ;
4700 PyObject * obj1 = 0 ;
4701 char * kwnames[] = {
4702 (char *) "self",(char *) "other", NULL
4703 };
4704
4705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4707 if (!SWIG_IsOK(res1)) {
4708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4709 }
4710 arg1 = reinterpret_cast< wxSize * >(argp1);
4711 arg2 = obj1;
4712 {
4713 result = (bool)wxSize___ne__(arg1,arg2);
4714 if (PyErr_Occurred()) SWIG_fail;
4715 }
4716 {
4717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4718 }
4719 return resultobj;
4720 fail:
4721 return NULL;
4722 }
4723
4724
4725 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4726 PyObject *resultobj = 0;
4727 wxSize *arg1 = (wxSize *) 0 ;
4728 wxSize *arg2 = 0 ;
4729 wxSize result;
4730 void *argp1 = 0 ;
4731 int res1 = 0 ;
4732 wxSize temp2 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 char * kwnames[] = {
4736 (char *) "self",(char *) "sz", NULL
4737 };
4738
4739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4741 if (!SWIG_IsOK(res1)) {
4742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4743 }
4744 arg1 = reinterpret_cast< wxSize * >(argp1);
4745 {
4746 arg2 = &temp2;
4747 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4748 }
4749 {
4750 PyThreadState* __tstate = wxPyBeginAllowThreads();
4751 result = (arg1)->operator +((wxSize const &)*arg2);
4752 wxPyEndAllowThreads(__tstate);
4753 if (PyErr_Occurred()) SWIG_fail;
4754 }
4755 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4756 return resultobj;
4757 fail:
4758 return NULL;
4759 }
4760
4761
4762 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4763 PyObject *resultobj = 0;
4764 wxSize *arg1 = (wxSize *) 0 ;
4765 wxSize *arg2 = 0 ;
4766 wxSize result;
4767 void *argp1 = 0 ;
4768 int res1 = 0 ;
4769 wxSize temp2 ;
4770 PyObject * obj0 = 0 ;
4771 PyObject * obj1 = 0 ;
4772 char * kwnames[] = {
4773 (char *) "self",(char *) "sz", NULL
4774 };
4775
4776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4778 if (!SWIG_IsOK(res1)) {
4779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4780 }
4781 arg1 = reinterpret_cast< wxSize * >(argp1);
4782 {
4783 arg2 = &temp2;
4784 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4785 }
4786 {
4787 PyThreadState* __tstate = wxPyBeginAllowThreads();
4788 result = (arg1)->operator -((wxSize const &)*arg2);
4789 wxPyEndAllowThreads(__tstate);
4790 if (PyErr_Occurred()) SWIG_fail;
4791 }
4792 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4793 return resultobj;
4794 fail:
4795 return NULL;
4796 }
4797
4798
4799 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4800 PyObject *resultobj = 0;
4801 wxSize *arg1 = (wxSize *) 0 ;
4802 wxSize *arg2 = 0 ;
4803 void *argp1 = 0 ;
4804 int res1 = 0 ;
4805 wxSize temp2 ;
4806 PyObject * obj0 = 0 ;
4807 PyObject * obj1 = 0 ;
4808 char * kwnames[] = {
4809 (char *) "self",(char *) "sz", NULL
4810 };
4811
4812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4814 if (!SWIG_IsOK(res1)) {
4815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4816 }
4817 arg1 = reinterpret_cast< wxSize * >(argp1);
4818 {
4819 arg2 = &temp2;
4820 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4821 }
4822 {
4823 PyThreadState* __tstate = wxPyBeginAllowThreads();
4824 (arg1)->IncTo((wxSize const &)*arg2);
4825 wxPyEndAllowThreads(__tstate);
4826 if (PyErr_Occurred()) SWIG_fail;
4827 }
4828 resultobj = SWIG_Py_Void();
4829 return resultobj;
4830 fail:
4831 return NULL;
4832 }
4833
4834
4835 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4836 PyObject *resultobj = 0;
4837 wxSize *arg1 = (wxSize *) 0 ;
4838 wxSize *arg2 = 0 ;
4839 void *argp1 = 0 ;
4840 int res1 = 0 ;
4841 wxSize temp2 ;
4842 PyObject * obj0 = 0 ;
4843 PyObject * obj1 = 0 ;
4844 char * kwnames[] = {
4845 (char *) "self",(char *) "sz", NULL
4846 };
4847
4848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4850 if (!SWIG_IsOK(res1)) {
4851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4852 }
4853 arg1 = reinterpret_cast< wxSize * >(argp1);
4854 {
4855 arg2 = &temp2;
4856 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4857 }
4858 {
4859 PyThreadState* __tstate = wxPyBeginAllowThreads();
4860 (arg1)->DecTo((wxSize const &)*arg2);
4861 wxPyEndAllowThreads(__tstate);
4862 if (PyErr_Occurred()) SWIG_fail;
4863 }
4864 resultobj = SWIG_Py_Void();
4865 return resultobj;
4866 fail:
4867 return NULL;
4868 }
4869
4870
4871 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4872 PyObject *resultobj = 0;
4873 wxSize *arg1 = (wxSize *) 0 ;
4874 float arg2 ;
4875 float arg3 ;
4876 void *argp1 = 0 ;
4877 int res1 = 0 ;
4878 float val2 ;
4879 int ecode2 = 0 ;
4880 float val3 ;
4881 int ecode3 = 0 ;
4882 PyObject * obj0 = 0 ;
4883 PyObject * obj1 = 0 ;
4884 PyObject * obj2 = 0 ;
4885 char * kwnames[] = {
4886 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4887 };
4888
4889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4891 if (!SWIG_IsOK(res1)) {
4892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4893 }
4894 arg1 = reinterpret_cast< wxSize * >(argp1);
4895 ecode2 = SWIG_AsVal_float(obj1, &val2);
4896 if (!SWIG_IsOK(ecode2)) {
4897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4898 }
4899 arg2 = static_cast< float >(val2);
4900 ecode3 = SWIG_AsVal_float(obj2, &val3);
4901 if (!SWIG_IsOK(ecode3)) {
4902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4903 }
4904 arg3 = static_cast< float >(val3);
4905 {
4906 PyThreadState* __tstate = wxPyBeginAllowThreads();
4907 (arg1)->Scale(arg2,arg3);
4908 wxPyEndAllowThreads(__tstate);
4909 if (PyErr_Occurred()) SWIG_fail;
4910 }
4911 resultobj = SWIG_Py_Void();
4912 return resultobj;
4913 fail:
4914 return NULL;
4915 }
4916
4917
4918 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4919 PyObject *resultobj = 0;
4920 wxSize *arg1 = (wxSize *) 0 ;
4921 int arg2 ;
4922 int arg3 ;
4923 void *argp1 = 0 ;
4924 int res1 = 0 ;
4925 int val2 ;
4926 int ecode2 = 0 ;
4927 int val3 ;
4928 int ecode3 = 0 ;
4929 PyObject * obj0 = 0 ;
4930 PyObject * obj1 = 0 ;
4931 PyObject * obj2 = 0 ;
4932 char * kwnames[] = {
4933 (char *) "self",(char *) "w",(char *) "h", NULL
4934 };
4935
4936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4938 if (!SWIG_IsOK(res1)) {
4939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4940 }
4941 arg1 = reinterpret_cast< wxSize * >(argp1);
4942 ecode2 = SWIG_AsVal_int(obj1, &val2);
4943 if (!SWIG_IsOK(ecode2)) {
4944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4945 }
4946 arg2 = static_cast< int >(val2);
4947 ecode3 = SWIG_AsVal_int(obj2, &val3);
4948 if (!SWIG_IsOK(ecode3)) {
4949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4950 }
4951 arg3 = static_cast< int >(val3);
4952 {
4953 PyThreadState* __tstate = wxPyBeginAllowThreads();
4954 (arg1)->Set(arg2,arg3);
4955 wxPyEndAllowThreads(__tstate);
4956 if (PyErr_Occurred()) SWIG_fail;
4957 }
4958 resultobj = SWIG_Py_Void();
4959 return resultobj;
4960 fail:
4961 return NULL;
4962 }
4963
4964
4965 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4966 PyObject *resultobj = 0;
4967 wxSize *arg1 = (wxSize *) 0 ;
4968 int arg2 ;
4969 void *argp1 = 0 ;
4970 int res1 = 0 ;
4971 int val2 ;
4972 int ecode2 = 0 ;
4973 PyObject * obj0 = 0 ;
4974 PyObject * obj1 = 0 ;
4975 char * kwnames[] = {
4976 (char *) "self",(char *) "w", NULL
4977 };
4978
4979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4981 if (!SWIG_IsOK(res1)) {
4982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4983 }
4984 arg1 = reinterpret_cast< wxSize * >(argp1);
4985 ecode2 = SWIG_AsVal_int(obj1, &val2);
4986 if (!SWIG_IsOK(ecode2)) {
4987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4988 }
4989 arg2 = static_cast< int >(val2);
4990 {
4991 PyThreadState* __tstate = wxPyBeginAllowThreads();
4992 (arg1)->SetWidth(arg2);
4993 wxPyEndAllowThreads(__tstate);
4994 if (PyErr_Occurred()) SWIG_fail;
4995 }
4996 resultobj = SWIG_Py_Void();
4997 return resultobj;
4998 fail:
4999 return NULL;
5000 }
5001
5002
5003 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5004 PyObject *resultobj = 0;
5005 wxSize *arg1 = (wxSize *) 0 ;
5006 int arg2 ;
5007 void *argp1 = 0 ;
5008 int res1 = 0 ;
5009 int val2 ;
5010 int ecode2 = 0 ;
5011 PyObject * obj0 = 0 ;
5012 PyObject * obj1 = 0 ;
5013 char * kwnames[] = {
5014 (char *) "self",(char *) "h", NULL
5015 };
5016
5017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5019 if (!SWIG_IsOK(res1)) {
5020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5021 }
5022 arg1 = reinterpret_cast< wxSize * >(argp1);
5023 ecode2 = SWIG_AsVal_int(obj1, &val2);
5024 if (!SWIG_IsOK(ecode2)) {
5025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5026 }
5027 arg2 = static_cast< int >(val2);
5028 {
5029 PyThreadState* __tstate = wxPyBeginAllowThreads();
5030 (arg1)->SetHeight(arg2);
5031 wxPyEndAllowThreads(__tstate);
5032 if (PyErr_Occurred()) SWIG_fail;
5033 }
5034 resultobj = SWIG_Py_Void();
5035 return resultobj;
5036 fail:
5037 return NULL;
5038 }
5039
5040
5041 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5042 PyObject *resultobj = 0;
5043 wxSize *arg1 = (wxSize *) 0 ;
5044 int result;
5045 void *argp1 = 0 ;
5046 int res1 = 0 ;
5047 PyObject *swig_obj[1] ;
5048
5049 if (!args) SWIG_fail;
5050 swig_obj[0] = args;
5051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5052 if (!SWIG_IsOK(res1)) {
5053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5054 }
5055 arg1 = reinterpret_cast< wxSize * >(argp1);
5056 {
5057 PyThreadState* __tstate = wxPyBeginAllowThreads();
5058 result = (int)((wxSize const *)arg1)->GetWidth();
5059 wxPyEndAllowThreads(__tstate);
5060 if (PyErr_Occurred()) SWIG_fail;
5061 }
5062 resultobj = SWIG_From_int(static_cast< int >(result));
5063 return resultobj;
5064 fail:
5065 return NULL;
5066 }
5067
5068
5069 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5070 PyObject *resultobj = 0;
5071 wxSize *arg1 = (wxSize *) 0 ;
5072 int result;
5073 void *argp1 = 0 ;
5074 int res1 = 0 ;
5075 PyObject *swig_obj[1] ;
5076
5077 if (!args) SWIG_fail;
5078 swig_obj[0] = args;
5079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5080 if (!SWIG_IsOK(res1)) {
5081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5082 }
5083 arg1 = reinterpret_cast< wxSize * >(argp1);
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 result = (int)((wxSize const *)arg1)->GetHeight();
5087 wxPyEndAllowThreads(__tstate);
5088 if (PyErr_Occurred()) SWIG_fail;
5089 }
5090 resultobj = SWIG_From_int(static_cast< int >(result));
5091 return resultobj;
5092 fail:
5093 return NULL;
5094 }
5095
5096
5097 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5098 PyObject *resultobj = 0;
5099 wxSize *arg1 = (wxSize *) 0 ;
5100 bool result;
5101 void *argp1 = 0 ;
5102 int res1 = 0 ;
5103 PyObject *swig_obj[1] ;
5104
5105 if (!args) SWIG_fail;
5106 swig_obj[0] = args;
5107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5108 if (!SWIG_IsOK(res1)) {
5109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5110 }
5111 arg1 = reinterpret_cast< wxSize * >(argp1);
5112 {
5113 PyThreadState* __tstate = wxPyBeginAllowThreads();
5114 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5115 wxPyEndAllowThreads(__tstate);
5116 if (PyErr_Occurred()) SWIG_fail;
5117 }
5118 {
5119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5120 }
5121 return resultobj;
5122 fail:
5123 return NULL;
5124 }
5125
5126
5127 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5128 PyObject *resultobj = 0;
5129 wxSize *arg1 = (wxSize *) 0 ;
5130 wxSize *arg2 = 0 ;
5131 void *argp1 = 0 ;
5132 int res1 = 0 ;
5133 wxSize temp2 ;
5134 PyObject * obj0 = 0 ;
5135 PyObject * obj1 = 0 ;
5136 char * kwnames[] = {
5137 (char *) "self",(char *) "size", NULL
5138 };
5139
5140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5142 if (!SWIG_IsOK(res1)) {
5143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5144 }
5145 arg1 = reinterpret_cast< wxSize * >(argp1);
5146 {
5147 arg2 = &temp2;
5148 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5149 }
5150 {
5151 PyThreadState* __tstate = wxPyBeginAllowThreads();
5152 (arg1)->SetDefaults((wxSize const &)*arg2);
5153 wxPyEndAllowThreads(__tstate);
5154 if (PyErr_Occurred()) SWIG_fail;
5155 }
5156 resultobj = SWIG_Py_Void();
5157 return resultobj;
5158 fail:
5159 return NULL;
5160 }
5161
5162
5163 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5164 PyObject *resultobj = 0;
5165 wxSize *arg1 = (wxSize *) 0 ;
5166 PyObject *result = 0 ;
5167 void *argp1 = 0 ;
5168 int res1 = 0 ;
5169 PyObject *swig_obj[1] ;
5170
5171 if (!args) SWIG_fail;
5172 swig_obj[0] = args;
5173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5174 if (!SWIG_IsOK(res1)) {
5175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5176 }
5177 arg1 = reinterpret_cast< wxSize * >(argp1);
5178 {
5179 PyThreadState* __tstate = wxPyBeginAllowThreads();
5180 result = (PyObject *)wxSize_Get(arg1);
5181 wxPyEndAllowThreads(__tstate);
5182 if (PyErr_Occurred()) SWIG_fail;
5183 }
5184 resultobj = result;
5185 return resultobj;
5186 fail:
5187 return NULL;
5188 }
5189
5190
5191 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5192 PyObject *obj;
5193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5194 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5195 return SWIG_Py_Void();
5196 }
5197
5198 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5199 return SWIG_Python_InitShadowInstance(args);
5200 }
5201
5202 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5203 PyObject *resultobj = 0;
5204 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5205 double arg2 ;
5206 void *argp1 = 0 ;
5207 int res1 = 0 ;
5208 double val2 ;
5209 int ecode2 = 0 ;
5210 PyObject *swig_obj[2] ;
5211
5212 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5214 if (!SWIG_IsOK(res1)) {
5215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5216 }
5217 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5218 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5219 if (!SWIG_IsOK(ecode2)) {
5220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5221 }
5222 arg2 = static_cast< double >(val2);
5223 if (arg1) (arg1)->x = arg2;
5224
5225 resultobj = SWIG_Py_Void();
5226 return resultobj;
5227 fail:
5228 return NULL;
5229 }
5230
5231
5232 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5233 PyObject *resultobj = 0;
5234 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5235 double result;
5236 void *argp1 = 0 ;
5237 int res1 = 0 ;
5238 PyObject *swig_obj[1] ;
5239
5240 if (!args) SWIG_fail;
5241 swig_obj[0] = args;
5242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5243 if (!SWIG_IsOK(res1)) {
5244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5245 }
5246 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5247 result = (double) ((arg1)->x);
5248 resultobj = SWIG_From_double(static_cast< double >(result));
5249 return resultobj;
5250 fail:
5251 return NULL;
5252 }
5253
5254
5255 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5256 PyObject *resultobj = 0;
5257 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5258 double arg2 ;
5259 void *argp1 = 0 ;
5260 int res1 = 0 ;
5261 double val2 ;
5262 int ecode2 = 0 ;
5263 PyObject *swig_obj[2] ;
5264
5265 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5267 if (!SWIG_IsOK(res1)) {
5268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5269 }
5270 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5271 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5272 if (!SWIG_IsOK(ecode2)) {
5273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5274 }
5275 arg2 = static_cast< double >(val2);
5276 if (arg1) (arg1)->y = arg2;
5277
5278 resultobj = SWIG_Py_Void();
5279 return resultobj;
5280 fail:
5281 return NULL;
5282 }
5283
5284
5285 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5286 PyObject *resultobj = 0;
5287 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5288 double result;
5289 void *argp1 = 0 ;
5290 int res1 = 0 ;
5291 PyObject *swig_obj[1] ;
5292
5293 if (!args) SWIG_fail;
5294 swig_obj[0] = args;
5295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5296 if (!SWIG_IsOK(res1)) {
5297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5298 }
5299 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5300 result = (double) ((arg1)->y);
5301 resultobj = SWIG_From_double(static_cast< double >(result));
5302 return resultobj;
5303 fail:
5304 return NULL;
5305 }
5306
5307
5308 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5309 PyObject *resultobj = 0;
5310 double arg1 = (double) 0.0 ;
5311 double arg2 = (double) 0.0 ;
5312 wxRealPoint *result = 0 ;
5313 double val1 ;
5314 int ecode1 = 0 ;
5315 double val2 ;
5316 int ecode2 = 0 ;
5317 PyObject * obj0 = 0 ;
5318 PyObject * obj1 = 0 ;
5319 char * kwnames[] = {
5320 (char *) "x",(char *) "y", NULL
5321 };
5322
5323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5324 if (obj0) {
5325 ecode1 = SWIG_AsVal_double(obj0, &val1);
5326 if (!SWIG_IsOK(ecode1)) {
5327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5328 }
5329 arg1 = static_cast< double >(val1);
5330 }
5331 if (obj1) {
5332 ecode2 = SWIG_AsVal_double(obj1, &val2);
5333 if (!SWIG_IsOK(ecode2)) {
5334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5335 }
5336 arg2 = static_cast< double >(val2);
5337 }
5338 {
5339 PyThreadState* __tstate = wxPyBeginAllowThreads();
5340 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5341 wxPyEndAllowThreads(__tstate);
5342 if (PyErr_Occurred()) SWIG_fail;
5343 }
5344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5345 return resultobj;
5346 fail:
5347 return NULL;
5348 }
5349
5350
5351 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5352 PyObject *resultobj = 0;
5353 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5354 void *argp1 = 0 ;
5355 int res1 = 0 ;
5356 PyObject *swig_obj[1] ;
5357
5358 if (!args) SWIG_fail;
5359 swig_obj[0] = args;
5360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5361 if (!SWIG_IsOK(res1)) {
5362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5363 }
5364 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5365 {
5366 PyThreadState* __tstate = wxPyBeginAllowThreads();
5367 delete arg1;
5368
5369 wxPyEndAllowThreads(__tstate);
5370 if (PyErr_Occurred()) SWIG_fail;
5371 }
5372 resultobj = SWIG_Py_Void();
5373 return resultobj;
5374 fail:
5375 return NULL;
5376 }
5377
5378
5379 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5380 PyObject *resultobj = 0;
5381 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5382 PyObject *arg2 = (PyObject *) 0 ;
5383 bool result;
5384 void *argp1 = 0 ;
5385 int res1 = 0 ;
5386 PyObject * obj0 = 0 ;
5387 PyObject * obj1 = 0 ;
5388 char * kwnames[] = {
5389 (char *) "self",(char *) "other", NULL
5390 };
5391
5392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5394 if (!SWIG_IsOK(res1)) {
5395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5396 }
5397 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5398 arg2 = obj1;
5399 {
5400 result = (bool)wxRealPoint___eq__(arg1,arg2);
5401 if (PyErr_Occurred()) SWIG_fail;
5402 }
5403 {
5404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5405 }
5406 return resultobj;
5407 fail:
5408 return NULL;
5409 }
5410
5411
5412 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5413 PyObject *resultobj = 0;
5414 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5415 PyObject *arg2 = (PyObject *) 0 ;
5416 bool result;
5417 void *argp1 = 0 ;
5418 int res1 = 0 ;
5419 PyObject * obj0 = 0 ;
5420 PyObject * obj1 = 0 ;
5421 char * kwnames[] = {
5422 (char *) "self",(char *) "other", NULL
5423 };
5424
5425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5427 if (!SWIG_IsOK(res1)) {
5428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5429 }
5430 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5431 arg2 = obj1;
5432 {
5433 result = (bool)wxRealPoint___ne__(arg1,arg2);
5434 if (PyErr_Occurred()) SWIG_fail;
5435 }
5436 {
5437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5438 }
5439 return resultobj;
5440 fail:
5441 return NULL;
5442 }
5443
5444
5445 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5446 PyObject *resultobj = 0;
5447 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5448 wxRealPoint *arg2 = 0 ;
5449 wxRealPoint result;
5450 void *argp1 = 0 ;
5451 int res1 = 0 ;
5452 wxRealPoint temp2 ;
5453 PyObject * obj0 = 0 ;
5454 PyObject * obj1 = 0 ;
5455 char * kwnames[] = {
5456 (char *) "self",(char *) "pt", NULL
5457 };
5458
5459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5461 if (!SWIG_IsOK(res1)) {
5462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5463 }
5464 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5465 {
5466 arg2 = &temp2;
5467 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5468 }
5469 {
5470 PyThreadState* __tstate = wxPyBeginAllowThreads();
5471 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5472 wxPyEndAllowThreads(__tstate);
5473 if (PyErr_Occurred()) SWIG_fail;
5474 }
5475 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5476 return resultobj;
5477 fail:
5478 return NULL;
5479 }
5480
5481
5482 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5483 PyObject *resultobj = 0;
5484 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5485 wxRealPoint *arg2 = 0 ;
5486 wxRealPoint result;
5487 void *argp1 = 0 ;
5488 int res1 = 0 ;
5489 wxRealPoint temp2 ;
5490 PyObject * obj0 = 0 ;
5491 PyObject * obj1 = 0 ;
5492 char * kwnames[] = {
5493 (char *) "self",(char *) "pt", NULL
5494 };
5495
5496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5498 if (!SWIG_IsOK(res1)) {
5499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5500 }
5501 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5502 {
5503 arg2 = &temp2;
5504 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5505 }
5506 {
5507 PyThreadState* __tstate = wxPyBeginAllowThreads();
5508 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5509 wxPyEndAllowThreads(__tstate);
5510 if (PyErr_Occurred()) SWIG_fail;
5511 }
5512 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5513 return resultobj;
5514 fail:
5515 return NULL;
5516 }
5517
5518
5519 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5520 PyObject *resultobj = 0;
5521 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5522 double arg2 ;
5523 double arg3 ;
5524 void *argp1 = 0 ;
5525 int res1 = 0 ;
5526 double val2 ;
5527 int ecode2 = 0 ;
5528 double val3 ;
5529 int ecode3 = 0 ;
5530 PyObject * obj0 = 0 ;
5531 PyObject * obj1 = 0 ;
5532 PyObject * obj2 = 0 ;
5533 char * kwnames[] = {
5534 (char *) "self",(char *) "x",(char *) "y", NULL
5535 };
5536
5537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5539 if (!SWIG_IsOK(res1)) {
5540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5541 }
5542 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5543 ecode2 = SWIG_AsVal_double(obj1, &val2);
5544 if (!SWIG_IsOK(ecode2)) {
5545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5546 }
5547 arg2 = static_cast< double >(val2);
5548 ecode3 = SWIG_AsVal_double(obj2, &val3);
5549 if (!SWIG_IsOK(ecode3)) {
5550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5551 }
5552 arg3 = static_cast< double >(val3);
5553 {
5554 PyThreadState* __tstate = wxPyBeginAllowThreads();
5555 wxRealPoint_Set(arg1,arg2,arg3);
5556 wxPyEndAllowThreads(__tstate);
5557 if (PyErr_Occurred()) SWIG_fail;
5558 }
5559 resultobj = SWIG_Py_Void();
5560 return resultobj;
5561 fail:
5562 return NULL;
5563 }
5564
5565
5566 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5567 PyObject *resultobj = 0;
5568 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5569 PyObject *result = 0 ;
5570 void *argp1 = 0 ;
5571 int res1 = 0 ;
5572 PyObject *swig_obj[1] ;
5573
5574 if (!args) SWIG_fail;
5575 swig_obj[0] = args;
5576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5577 if (!SWIG_IsOK(res1)) {
5578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5579 }
5580 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5581 {
5582 PyThreadState* __tstate = wxPyBeginAllowThreads();
5583 result = (PyObject *)wxRealPoint_Get(arg1);
5584 wxPyEndAllowThreads(__tstate);
5585 if (PyErr_Occurred()) SWIG_fail;
5586 }
5587 resultobj = result;
5588 return resultobj;
5589 fail:
5590 return NULL;
5591 }
5592
5593
5594 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5595 PyObject *obj;
5596 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5597 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5598 return SWIG_Py_Void();
5599 }
5600
5601 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5602 return SWIG_Python_InitShadowInstance(args);
5603 }
5604
5605 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5606 PyObject *resultobj = 0;
5607 wxPoint *arg1 = (wxPoint *) 0 ;
5608 int arg2 ;
5609 void *argp1 = 0 ;
5610 int res1 = 0 ;
5611 int val2 ;
5612 int ecode2 = 0 ;
5613 PyObject *swig_obj[2] ;
5614
5615 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5617 if (!SWIG_IsOK(res1)) {
5618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5619 }
5620 arg1 = reinterpret_cast< wxPoint * >(argp1);
5621 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5622 if (!SWIG_IsOK(ecode2)) {
5623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5624 }
5625 arg2 = static_cast< int >(val2);
5626 if (arg1) (arg1)->x = arg2;
5627
5628 resultobj = SWIG_Py_Void();
5629 return resultobj;
5630 fail:
5631 return NULL;
5632 }
5633
5634
5635 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5636 PyObject *resultobj = 0;
5637 wxPoint *arg1 = (wxPoint *) 0 ;
5638 int result;
5639 void *argp1 = 0 ;
5640 int res1 = 0 ;
5641 PyObject *swig_obj[1] ;
5642
5643 if (!args) SWIG_fail;
5644 swig_obj[0] = args;
5645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5646 if (!SWIG_IsOK(res1)) {
5647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5648 }
5649 arg1 = reinterpret_cast< wxPoint * >(argp1);
5650 result = (int) ((arg1)->x);
5651 resultobj = SWIG_From_int(static_cast< int >(result));
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5659 PyObject *resultobj = 0;
5660 wxPoint *arg1 = (wxPoint *) 0 ;
5661 int arg2 ;
5662 void *argp1 = 0 ;
5663 int res1 = 0 ;
5664 int val2 ;
5665 int ecode2 = 0 ;
5666 PyObject *swig_obj[2] ;
5667
5668 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5670 if (!SWIG_IsOK(res1)) {
5671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5672 }
5673 arg1 = reinterpret_cast< wxPoint * >(argp1);
5674 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5675 if (!SWIG_IsOK(ecode2)) {
5676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5677 }
5678 arg2 = static_cast< int >(val2);
5679 if (arg1) (arg1)->y = arg2;
5680
5681 resultobj = SWIG_Py_Void();
5682 return resultobj;
5683 fail:
5684 return NULL;
5685 }
5686
5687
5688 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5689 PyObject *resultobj = 0;
5690 wxPoint *arg1 = (wxPoint *) 0 ;
5691 int result;
5692 void *argp1 = 0 ;
5693 int res1 = 0 ;
5694 PyObject *swig_obj[1] ;
5695
5696 if (!args) SWIG_fail;
5697 swig_obj[0] = args;
5698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5699 if (!SWIG_IsOK(res1)) {
5700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5701 }
5702 arg1 = reinterpret_cast< wxPoint * >(argp1);
5703 result = (int) ((arg1)->y);
5704 resultobj = SWIG_From_int(static_cast< int >(result));
5705 return resultobj;
5706 fail:
5707 return NULL;
5708 }
5709
5710
5711 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5712 PyObject *resultobj = 0;
5713 int arg1 = (int) 0 ;
5714 int arg2 = (int) 0 ;
5715 wxPoint *result = 0 ;
5716 int val1 ;
5717 int ecode1 = 0 ;
5718 int val2 ;
5719 int ecode2 = 0 ;
5720 PyObject * obj0 = 0 ;
5721 PyObject * obj1 = 0 ;
5722 char * kwnames[] = {
5723 (char *) "x",(char *) "y", NULL
5724 };
5725
5726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5727 if (obj0) {
5728 ecode1 = SWIG_AsVal_int(obj0, &val1);
5729 if (!SWIG_IsOK(ecode1)) {
5730 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5731 }
5732 arg1 = static_cast< int >(val1);
5733 }
5734 if (obj1) {
5735 ecode2 = SWIG_AsVal_int(obj1, &val2);
5736 if (!SWIG_IsOK(ecode2)) {
5737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5738 }
5739 arg2 = static_cast< int >(val2);
5740 }
5741 {
5742 PyThreadState* __tstate = wxPyBeginAllowThreads();
5743 result = (wxPoint *)new wxPoint(arg1,arg2);
5744 wxPyEndAllowThreads(__tstate);
5745 if (PyErr_Occurred()) SWIG_fail;
5746 }
5747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5748 return resultobj;
5749 fail:
5750 return NULL;
5751 }
5752
5753
5754 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5755 PyObject *resultobj = 0;
5756 wxPoint *arg1 = (wxPoint *) 0 ;
5757 void *argp1 = 0 ;
5758 int res1 = 0 ;
5759 PyObject *swig_obj[1] ;
5760
5761 if (!args) SWIG_fail;
5762 swig_obj[0] = args;
5763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5764 if (!SWIG_IsOK(res1)) {
5765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5766 }
5767 arg1 = reinterpret_cast< wxPoint * >(argp1);
5768 {
5769 PyThreadState* __tstate = wxPyBeginAllowThreads();
5770 delete arg1;
5771
5772 wxPyEndAllowThreads(__tstate);
5773 if (PyErr_Occurred()) SWIG_fail;
5774 }
5775 resultobj = SWIG_Py_Void();
5776 return resultobj;
5777 fail:
5778 return NULL;
5779 }
5780
5781
5782 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5783 PyObject *resultobj = 0;
5784 wxPoint *arg1 = (wxPoint *) 0 ;
5785 PyObject *arg2 = (PyObject *) 0 ;
5786 bool result;
5787 void *argp1 = 0 ;
5788 int res1 = 0 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 char * kwnames[] = {
5792 (char *) "self",(char *) "other", NULL
5793 };
5794
5795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5797 if (!SWIG_IsOK(res1)) {
5798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5799 }
5800 arg1 = reinterpret_cast< wxPoint * >(argp1);
5801 arg2 = obj1;
5802 {
5803 result = (bool)wxPoint___eq__(arg1,arg2);
5804 if (PyErr_Occurred()) SWIG_fail;
5805 }
5806 {
5807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5808 }
5809 return resultobj;
5810 fail:
5811 return NULL;
5812 }
5813
5814
5815 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5816 PyObject *resultobj = 0;
5817 wxPoint *arg1 = (wxPoint *) 0 ;
5818 PyObject *arg2 = (PyObject *) 0 ;
5819 bool result;
5820 void *argp1 = 0 ;
5821 int res1 = 0 ;
5822 PyObject * obj0 = 0 ;
5823 PyObject * obj1 = 0 ;
5824 char * kwnames[] = {
5825 (char *) "self",(char *) "other", NULL
5826 };
5827
5828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5830 if (!SWIG_IsOK(res1)) {
5831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5832 }
5833 arg1 = reinterpret_cast< wxPoint * >(argp1);
5834 arg2 = obj1;
5835 {
5836 result = (bool)wxPoint___ne__(arg1,arg2);
5837 if (PyErr_Occurred()) SWIG_fail;
5838 }
5839 {
5840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5841 }
5842 return resultobj;
5843 fail:
5844 return NULL;
5845 }
5846
5847
5848 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5849 PyObject *resultobj = 0;
5850 wxPoint *arg1 = (wxPoint *) 0 ;
5851 wxPoint *arg2 = 0 ;
5852 wxPoint result;
5853 void *argp1 = 0 ;
5854 int res1 = 0 ;
5855 wxPoint temp2 ;
5856 PyObject * obj0 = 0 ;
5857 PyObject * obj1 = 0 ;
5858 char * kwnames[] = {
5859 (char *) "self",(char *) "pt", NULL
5860 };
5861
5862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5864 if (!SWIG_IsOK(res1)) {
5865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5866 }
5867 arg1 = reinterpret_cast< wxPoint * >(argp1);
5868 {
5869 arg2 = &temp2;
5870 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5871 }
5872 {
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 result = (arg1)->operator +((wxPoint const &)*arg2);
5875 wxPyEndAllowThreads(__tstate);
5876 if (PyErr_Occurred()) SWIG_fail;
5877 }
5878 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5879 return resultobj;
5880 fail:
5881 return NULL;
5882 }
5883
5884
5885 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5886 PyObject *resultobj = 0;
5887 wxPoint *arg1 = (wxPoint *) 0 ;
5888 wxPoint *arg2 = 0 ;
5889 wxPoint result;
5890 void *argp1 = 0 ;
5891 int res1 = 0 ;
5892 wxPoint temp2 ;
5893 PyObject * obj0 = 0 ;
5894 PyObject * obj1 = 0 ;
5895 char * kwnames[] = {
5896 (char *) "self",(char *) "pt", NULL
5897 };
5898
5899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5901 if (!SWIG_IsOK(res1)) {
5902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5903 }
5904 arg1 = reinterpret_cast< wxPoint * >(argp1);
5905 {
5906 arg2 = &temp2;
5907 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5908 }
5909 {
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 result = (arg1)->operator -((wxPoint const &)*arg2);
5912 wxPyEndAllowThreads(__tstate);
5913 if (PyErr_Occurred()) SWIG_fail;
5914 }
5915 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5916 return resultobj;
5917 fail:
5918 return NULL;
5919 }
5920
5921
5922 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5923 PyObject *resultobj = 0;
5924 wxPoint *arg1 = (wxPoint *) 0 ;
5925 wxPoint *arg2 = 0 ;
5926 wxPoint *result = 0 ;
5927 void *argp1 = 0 ;
5928 int res1 = 0 ;
5929 wxPoint temp2 ;
5930 PyObject * obj0 = 0 ;
5931 PyObject * obj1 = 0 ;
5932 char * kwnames[] = {
5933 (char *) "self",(char *) "pt", NULL
5934 };
5935
5936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5938 if (!SWIG_IsOK(res1)) {
5939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5940 }
5941 arg1 = reinterpret_cast< wxPoint * >(argp1);
5942 {
5943 arg2 = &temp2;
5944 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5945 }
5946 {
5947 PyThreadState* __tstate = wxPyBeginAllowThreads();
5948 {
5949 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5950 result = (wxPoint *) &_result_ref;
5951 }
5952 wxPyEndAllowThreads(__tstate);
5953 if (PyErr_Occurred()) SWIG_fail;
5954 }
5955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5956 return resultobj;
5957 fail:
5958 return NULL;
5959 }
5960
5961
5962 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5963 PyObject *resultobj = 0;
5964 wxPoint *arg1 = (wxPoint *) 0 ;
5965 wxPoint *arg2 = 0 ;
5966 wxPoint *result = 0 ;
5967 void *argp1 = 0 ;
5968 int res1 = 0 ;
5969 wxPoint temp2 ;
5970 PyObject * obj0 = 0 ;
5971 PyObject * obj1 = 0 ;
5972 char * kwnames[] = {
5973 (char *) "self",(char *) "pt", NULL
5974 };
5975
5976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5978 if (!SWIG_IsOK(res1)) {
5979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5980 }
5981 arg1 = reinterpret_cast< wxPoint * >(argp1);
5982 {
5983 arg2 = &temp2;
5984 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5985 }
5986 {
5987 PyThreadState* __tstate = wxPyBeginAllowThreads();
5988 {
5989 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5990 result = (wxPoint *) &_result_ref;
5991 }
5992 wxPyEndAllowThreads(__tstate);
5993 if (PyErr_Occurred()) SWIG_fail;
5994 }
5995 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5996 return resultobj;
5997 fail:
5998 return NULL;
5999 }
6000
6001
6002 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6003 PyObject *resultobj = 0;
6004 wxPoint *arg1 = (wxPoint *) 0 ;
6005 long arg2 ;
6006 long arg3 ;
6007 void *argp1 = 0 ;
6008 int res1 = 0 ;
6009 long val2 ;
6010 int ecode2 = 0 ;
6011 long val3 ;
6012 int ecode3 = 0 ;
6013 PyObject * obj0 = 0 ;
6014 PyObject * obj1 = 0 ;
6015 PyObject * obj2 = 0 ;
6016 char * kwnames[] = {
6017 (char *) "self",(char *) "x",(char *) "y", NULL
6018 };
6019
6020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6022 if (!SWIG_IsOK(res1)) {
6023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6024 }
6025 arg1 = reinterpret_cast< wxPoint * >(argp1);
6026 ecode2 = SWIG_AsVal_long(obj1, &val2);
6027 if (!SWIG_IsOK(ecode2)) {
6028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6029 }
6030 arg2 = static_cast< long >(val2);
6031 ecode3 = SWIG_AsVal_long(obj2, &val3);
6032 if (!SWIG_IsOK(ecode3)) {
6033 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6034 }
6035 arg3 = static_cast< long >(val3);
6036 {
6037 PyThreadState* __tstate = wxPyBeginAllowThreads();
6038 wxPoint_Set(arg1,arg2,arg3);
6039 wxPyEndAllowThreads(__tstate);
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 resultobj = SWIG_Py_Void();
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
6049 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6050 PyObject *resultobj = 0;
6051 wxPoint *arg1 = (wxPoint *) 0 ;
6052 PyObject *result = 0 ;
6053 void *argp1 = 0 ;
6054 int res1 = 0 ;
6055 PyObject *swig_obj[1] ;
6056
6057 if (!args) SWIG_fail;
6058 swig_obj[0] = args;
6059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6060 if (!SWIG_IsOK(res1)) {
6061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6062 }
6063 arg1 = reinterpret_cast< wxPoint * >(argp1);
6064 {
6065 PyThreadState* __tstate = wxPyBeginAllowThreads();
6066 result = (PyObject *)wxPoint_Get(arg1);
6067 wxPyEndAllowThreads(__tstate);
6068 if (PyErr_Occurred()) SWIG_fail;
6069 }
6070 resultobj = result;
6071 return resultobj;
6072 fail:
6073 return NULL;
6074 }
6075
6076
6077 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6078 PyObject *obj;
6079 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6080 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6081 return SWIG_Py_Void();
6082 }
6083
6084 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6085 return SWIG_Python_InitShadowInstance(args);
6086 }
6087
6088 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6089 PyObject *resultobj = 0;
6090 int arg1 = (int) 0 ;
6091 int arg2 = (int) 0 ;
6092 int arg3 = (int) 0 ;
6093 int arg4 = (int) 0 ;
6094 wxRect *result = 0 ;
6095 int val1 ;
6096 int ecode1 = 0 ;
6097 int val2 ;
6098 int ecode2 = 0 ;
6099 int val3 ;
6100 int ecode3 = 0 ;
6101 int val4 ;
6102 int ecode4 = 0 ;
6103 PyObject * obj0 = 0 ;
6104 PyObject * obj1 = 0 ;
6105 PyObject * obj2 = 0 ;
6106 PyObject * obj3 = 0 ;
6107 char * kwnames[] = {
6108 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6109 };
6110
6111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6112 if (obj0) {
6113 ecode1 = SWIG_AsVal_int(obj0, &val1);
6114 if (!SWIG_IsOK(ecode1)) {
6115 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6116 }
6117 arg1 = static_cast< int >(val1);
6118 }
6119 if (obj1) {
6120 ecode2 = SWIG_AsVal_int(obj1, &val2);
6121 if (!SWIG_IsOK(ecode2)) {
6122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6123 }
6124 arg2 = static_cast< int >(val2);
6125 }
6126 if (obj2) {
6127 ecode3 = SWIG_AsVal_int(obj2, &val3);
6128 if (!SWIG_IsOK(ecode3)) {
6129 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6130 }
6131 arg3 = static_cast< int >(val3);
6132 }
6133 if (obj3) {
6134 ecode4 = SWIG_AsVal_int(obj3, &val4);
6135 if (!SWIG_IsOK(ecode4)) {
6136 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6137 }
6138 arg4 = static_cast< int >(val4);
6139 }
6140 {
6141 PyThreadState* __tstate = wxPyBeginAllowThreads();
6142 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6143 wxPyEndAllowThreads(__tstate);
6144 if (PyErr_Occurred()) SWIG_fail;
6145 }
6146 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6147 return resultobj;
6148 fail:
6149 return NULL;
6150 }
6151
6152
6153 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6154 PyObject *resultobj = 0;
6155 wxPoint *arg1 = 0 ;
6156 wxPoint *arg2 = 0 ;
6157 wxRect *result = 0 ;
6158 wxPoint temp1 ;
6159 wxPoint temp2 ;
6160 PyObject * obj0 = 0 ;
6161 PyObject * obj1 = 0 ;
6162 char * kwnames[] = {
6163 (char *) "topLeft",(char *) "bottomRight", NULL
6164 };
6165
6166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6167 {
6168 arg1 = &temp1;
6169 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6170 }
6171 {
6172 arg2 = &temp2;
6173 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6174 }
6175 {
6176 PyThreadState* __tstate = wxPyBeginAllowThreads();
6177 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6178 wxPyEndAllowThreads(__tstate);
6179 if (PyErr_Occurred()) SWIG_fail;
6180 }
6181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6182 return resultobj;
6183 fail:
6184 return NULL;
6185 }
6186
6187
6188 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6189 PyObject *resultobj = 0;
6190 wxPoint *arg1 = 0 ;
6191 wxSize *arg2 = 0 ;
6192 wxRect *result = 0 ;
6193 wxPoint temp1 ;
6194 wxSize temp2 ;
6195 PyObject * obj0 = 0 ;
6196 PyObject * obj1 = 0 ;
6197 char * kwnames[] = {
6198 (char *) "pos",(char *) "size", NULL
6199 };
6200
6201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6202 {
6203 arg1 = &temp1;
6204 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6205 }
6206 {
6207 arg2 = &temp2;
6208 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6209 }
6210 {
6211 PyThreadState* __tstate = wxPyBeginAllowThreads();
6212 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6213 wxPyEndAllowThreads(__tstate);
6214 if (PyErr_Occurred()) SWIG_fail;
6215 }
6216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6217 return resultobj;
6218 fail:
6219 return NULL;
6220 }
6221
6222
6223 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6224 PyObject *resultobj = 0;
6225 wxSize *arg1 = 0 ;
6226 wxRect *result = 0 ;
6227 wxSize temp1 ;
6228 PyObject * obj0 = 0 ;
6229 char * kwnames[] = {
6230 (char *) "size", NULL
6231 };
6232
6233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6234 {
6235 arg1 = &temp1;
6236 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6237 }
6238 {
6239 PyThreadState* __tstate = wxPyBeginAllowThreads();
6240 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6241 wxPyEndAllowThreads(__tstate);
6242 if (PyErr_Occurred()) SWIG_fail;
6243 }
6244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6245 return resultobj;
6246 fail:
6247 return NULL;
6248 }
6249
6250
6251 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6252 PyObject *resultobj = 0;
6253 wxRect *arg1 = (wxRect *) 0 ;
6254 void *argp1 = 0 ;
6255 int res1 = 0 ;
6256 PyObject *swig_obj[1] ;
6257
6258 if (!args) SWIG_fail;
6259 swig_obj[0] = args;
6260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6261 if (!SWIG_IsOK(res1)) {
6262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6263 }
6264 arg1 = reinterpret_cast< wxRect * >(argp1);
6265 {
6266 PyThreadState* __tstate = wxPyBeginAllowThreads();
6267 delete arg1;
6268
6269 wxPyEndAllowThreads(__tstate);
6270 if (PyErr_Occurred()) SWIG_fail;
6271 }
6272 resultobj = SWIG_Py_Void();
6273 return resultobj;
6274 fail:
6275 return NULL;
6276 }
6277
6278
6279 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6280 PyObject *resultobj = 0;
6281 wxRect *arg1 = (wxRect *) 0 ;
6282 int result;
6283 void *argp1 = 0 ;
6284 int res1 = 0 ;
6285 PyObject *swig_obj[1] ;
6286
6287 if (!args) SWIG_fail;
6288 swig_obj[0] = args;
6289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6290 if (!SWIG_IsOK(res1)) {
6291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6292 }
6293 arg1 = reinterpret_cast< wxRect * >(argp1);
6294 {
6295 PyThreadState* __tstate = wxPyBeginAllowThreads();
6296 result = (int)((wxRect const *)arg1)->GetX();
6297 wxPyEndAllowThreads(__tstate);
6298 if (PyErr_Occurred()) SWIG_fail;
6299 }
6300 resultobj = SWIG_From_int(static_cast< int >(result));
6301 return resultobj;
6302 fail:
6303 return NULL;
6304 }
6305
6306
6307 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6308 PyObject *resultobj = 0;
6309 wxRect *arg1 = (wxRect *) 0 ;
6310 int arg2 ;
6311 void *argp1 = 0 ;
6312 int res1 = 0 ;
6313 int val2 ;
6314 int ecode2 = 0 ;
6315 PyObject * obj0 = 0 ;
6316 PyObject * obj1 = 0 ;
6317 char * kwnames[] = {
6318 (char *) "self",(char *) "x", NULL
6319 };
6320
6321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6323 if (!SWIG_IsOK(res1)) {
6324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6325 }
6326 arg1 = reinterpret_cast< wxRect * >(argp1);
6327 ecode2 = SWIG_AsVal_int(obj1, &val2);
6328 if (!SWIG_IsOK(ecode2)) {
6329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6330 }
6331 arg2 = static_cast< int >(val2);
6332 {
6333 PyThreadState* __tstate = wxPyBeginAllowThreads();
6334 (arg1)->SetX(arg2);
6335 wxPyEndAllowThreads(__tstate);
6336 if (PyErr_Occurred()) SWIG_fail;
6337 }
6338 resultobj = SWIG_Py_Void();
6339 return resultobj;
6340 fail:
6341 return NULL;
6342 }
6343
6344
6345 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6346 PyObject *resultobj = 0;
6347 wxRect *arg1 = (wxRect *) 0 ;
6348 int result;
6349 void *argp1 = 0 ;
6350 int res1 = 0 ;
6351 PyObject *swig_obj[1] ;
6352
6353 if (!args) SWIG_fail;
6354 swig_obj[0] = args;
6355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6356 if (!SWIG_IsOK(res1)) {
6357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6358 }
6359 arg1 = reinterpret_cast< wxRect * >(argp1);
6360 {
6361 PyThreadState* __tstate = wxPyBeginAllowThreads();
6362 result = (int)(arg1)->GetY();
6363 wxPyEndAllowThreads(__tstate);
6364 if (PyErr_Occurred()) SWIG_fail;
6365 }
6366 resultobj = SWIG_From_int(static_cast< int >(result));
6367 return resultobj;
6368 fail:
6369 return NULL;
6370 }
6371
6372
6373 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6374 PyObject *resultobj = 0;
6375 wxRect *arg1 = (wxRect *) 0 ;
6376 int arg2 ;
6377 void *argp1 = 0 ;
6378 int res1 = 0 ;
6379 int val2 ;
6380 int ecode2 = 0 ;
6381 PyObject * obj0 = 0 ;
6382 PyObject * obj1 = 0 ;
6383 char * kwnames[] = {
6384 (char *) "self",(char *) "y", NULL
6385 };
6386
6387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6389 if (!SWIG_IsOK(res1)) {
6390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6391 }
6392 arg1 = reinterpret_cast< wxRect * >(argp1);
6393 ecode2 = SWIG_AsVal_int(obj1, &val2);
6394 if (!SWIG_IsOK(ecode2)) {
6395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6396 }
6397 arg2 = static_cast< int >(val2);
6398 {
6399 PyThreadState* __tstate = wxPyBeginAllowThreads();
6400 (arg1)->SetY(arg2);
6401 wxPyEndAllowThreads(__tstate);
6402 if (PyErr_Occurred()) SWIG_fail;
6403 }
6404 resultobj = SWIG_Py_Void();
6405 return resultobj;
6406 fail:
6407 return NULL;
6408 }
6409
6410
6411 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6412 PyObject *resultobj = 0;
6413 wxRect *arg1 = (wxRect *) 0 ;
6414 int result;
6415 void *argp1 = 0 ;
6416 int res1 = 0 ;
6417 PyObject *swig_obj[1] ;
6418
6419 if (!args) SWIG_fail;
6420 swig_obj[0] = args;
6421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6422 if (!SWIG_IsOK(res1)) {
6423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6424 }
6425 arg1 = reinterpret_cast< wxRect * >(argp1);
6426 {
6427 PyThreadState* __tstate = wxPyBeginAllowThreads();
6428 result = (int)((wxRect const *)arg1)->GetWidth();
6429 wxPyEndAllowThreads(__tstate);
6430 if (PyErr_Occurred()) SWIG_fail;
6431 }
6432 resultobj = SWIG_From_int(static_cast< int >(result));
6433 return resultobj;
6434 fail:
6435 return NULL;
6436 }
6437
6438
6439 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6440 PyObject *resultobj = 0;
6441 wxRect *arg1 = (wxRect *) 0 ;
6442 int arg2 ;
6443 void *argp1 = 0 ;
6444 int res1 = 0 ;
6445 int val2 ;
6446 int ecode2 = 0 ;
6447 PyObject * obj0 = 0 ;
6448 PyObject * obj1 = 0 ;
6449 char * kwnames[] = {
6450 (char *) "self",(char *) "w", NULL
6451 };
6452
6453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6455 if (!SWIG_IsOK(res1)) {
6456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6457 }
6458 arg1 = reinterpret_cast< wxRect * >(argp1);
6459 ecode2 = SWIG_AsVal_int(obj1, &val2);
6460 if (!SWIG_IsOK(ecode2)) {
6461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6462 }
6463 arg2 = static_cast< int >(val2);
6464 {
6465 PyThreadState* __tstate = wxPyBeginAllowThreads();
6466 (arg1)->SetWidth(arg2);
6467 wxPyEndAllowThreads(__tstate);
6468 if (PyErr_Occurred()) SWIG_fail;
6469 }
6470 resultobj = SWIG_Py_Void();
6471 return resultobj;
6472 fail:
6473 return NULL;
6474 }
6475
6476
6477 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6478 PyObject *resultobj = 0;
6479 wxRect *arg1 = (wxRect *) 0 ;
6480 int result;
6481 void *argp1 = 0 ;
6482 int res1 = 0 ;
6483 PyObject *swig_obj[1] ;
6484
6485 if (!args) SWIG_fail;
6486 swig_obj[0] = args;
6487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6488 if (!SWIG_IsOK(res1)) {
6489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6490 }
6491 arg1 = reinterpret_cast< wxRect * >(argp1);
6492 {
6493 PyThreadState* __tstate = wxPyBeginAllowThreads();
6494 result = (int)((wxRect const *)arg1)->GetHeight();
6495 wxPyEndAllowThreads(__tstate);
6496 if (PyErr_Occurred()) SWIG_fail;
6497 }
6498 resultobj = SWIG_From_int(static_cast< int >(result));
6499 return resultobj;
6500 fail:
6501 return NULL;
6502 }
6503
6504
6505 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6506 PyObject *resultobj = 0;
6507 wxRect *arg1 = (wxRect *) 0 ;
6508 int arg2 ;
6509 void *argp1 = 0 ;
6510 int res1 = 0 ;
6511 int val2 ;
6512 int ecode2 = 0 ;
6513 PyObject * obj0 = 0 ;
6514 PyObject * obj1 = 0 ;
6515 char * kwnames[] = {
6516 (char *) "self",(char *) "h", NULL
6517 };
6518
6519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6521 if (!SWIG_IsOK(res1)) {
6522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6523 }
6524 arg1 = reinterpret_cast< wxRect * >(argp1);
6525 ecode2 = SWIG_AsVal_int(obj1, &val2);
6526 if (!SWIG_IsOK(ecode2)) {
6527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6528 }
6529 arg2 = static_cast< int >(val2);
6530 {
6531 PyThreadState* __tstate = wxPyBeginAllowThreads();
6532 (arg1)->SetHeight(arg2);
6533 wxPyEndAllowThreads(__tstate);
6534 if (PyErr_Occurred()) SWIG_fail;
6535 }
6536 resultobj = SWIG_Py_Void();
6537 return resultobj;
6538 fail:
6539 return NULL;
6540 }
6541
6542
6543 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6544 PyObject *resultobj = 0;
6545 wxRect *arg1 = (wxRect *) 0 ;
6546 wxPoint result;
6547 void *argp1 = 0 ;
6548 int res1 = 0 ;
6549 PyObject *swig_obj[1] ;
6550
6551 if (!args) SWIG_fail;
6552 swig_obj[0] = args;
6553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6554 if (!SWIG_IsOK(res1)) {
6555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6556 }
6557 arg1 = reinterpret_cast< wxRect * >(argp1);
6558 {
6559 PyThreadState* __tstate = wxPyBeginAllowThreads();
6560 result = ((wxRect const *)arg1)->GetPosition();
6561 wxPyEndAllowThreads(__tstate);
6562 if (PyErr_Occurred()) SWIG_fail;
6563 }
6564 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6565 return resultobj;
6566 fail:
6567 return NULL;
6568 }
6569
6570
6571 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6572 PyObject *resultobj = 0;
6573 wxRect *arg1 = (wxRect *) 0 ;
6574 wxPoint *arg2 = 0 ;
6575 void *argp1 = 0 ;
6576 int res1 = 0 ;
6577 wxPoint temp2 ;
6578 PyObject * obj0 = 0 ;
6579 PyObject * obj1 = 0 ;
6580 char * kwnames[] = {
6581 (char *) "self",(char *) "p", NULL
6582 };
6583
6584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6586 if (!SWIG_IsOK(res1)) {
6587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6588 }
6589 arg1 = reinterpret_cast< wxRect * >(argp1);
6590 {
6591 arg2 = &temp2;
6592 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6593 }
6594 {
6595 PyThreadState* __tstate = wxPyBeginAllowThreads();
6596 (arg1)->SetPosition((wxPoint const &)*arg2);
6597 wxPyEndAllowThreads(__tstate);
6598 if (PyErr_Occurred()) SWIG_fail;
6599 }
6600 resultobj = SWIG_Py_Void();
6601 return resultobj;
6602 fail:
6603 return NULL;
6604 }
6605
6606
6607 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6608 PyObject *resultobj = 0;
6609 wxRect *arg1 = (wxRect *) 0 ;
6610 wxSize result;
6611 void *argp1 = 0 ;
6612 int res1 = 0 ;
6613 PyObject *swig_obj[1] ;
6614
6615 if (!args) SWIG_fail;
6616 swig_obj[0] = args;
6617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6618 if (!SWIG_IsOK(res1)) {
6619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6620 }
6621 arg1 = reinterpret_cast< wxRect * >(argp1);
6622 {
6623 PyThreadState* __tstate = wxPyBeginAllowThreads();
6624 result = ((wxRect const *)arg1)->GetSize();
6625 wxPyEndAllowThreads(__tstate);
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6636 PyObject *resultobj = 0;
6637 wxRect *arg1 = (wxRect *) 0 ;
6638 wxSize *arg2 = 0 ;
6639 void *argp1 = 0 ;
6640 int res1 = 0 ;
6641 wxSize temp2 ;
6642 PyObject * obj0 = 0 ;
6643 PyObject * obj1 = 0 ;
6644 char * kwnames[] = {
6645 (char *) "self",(char *) "s", NULL
6646 };
6647
6648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6650 if (!SWIG_IsOK(res1)) {
6651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6652 }
6653 arg1 = reinterpret_cast< wxRect * >(argp1);
6654 {
6655 arg2 = &temp2;
6656 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6657 }
6658 {
6659 PyThreadState* __tstate = wxPyBeginAllowThreads();
6660 (arg1)->SetSize((wxSize const &)*arg2);
6661 wxPyEndAllowThreads(__tstate);
6662 if (PyErr_Occurred()) SWIG_fail;
6663 }
6664 resultobj = SWIG_Py_Void();
6665 return resultobj;
6666 fail:
6667 return NULL;
6668 }
6669
6670
6671 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6672 PyObject *resultobj = 0;
6673 wxRect *arg1 = (wxRect *) 0 ;
6674 bool result;
6675 void *argp1 = 0 ;
6676 int res1 = 0 ;
6677 PyObject *swig_obj[1] ;
6678
6679 if (!args) SWIG_fail;
6680 swig_obj[0] = args;
6681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6682 if (!SWIG_IsOK(res1)) {
6683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6684 }
6685 arg1 = reinterpret_cast< wxRect * >(argp1);
6686 {
6687 PyThreadState* __tstate = wxPyBeginAllowThreads();
6688 result = (bool)((wxRect const *)arg1)->IsEmpty();
6689 wxPyEndAllowThreads(__tstate);
6690 if (PyErr_Occurred()) SWIG_fail;
6691 }
6692 {
6693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6694 }
6695 return resultobj;
6696 fail:
6697 return NULL;
6698 }
6699
6700
6701 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6702 PyObject *resultobj = 0;
6703 wxRect *arg1 = (wxRect *) 0 ;
6704 wxPoint result;
6705 void *argp1 = 0 ;
6706 int res1 = 0 ;
6707 PyObject *swig_obj[1] ;
6708
6709 if (!args) SWIG_fail;
6710 swig_obj[0] = args;
6711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6712 if (!SWIG_IsOK(res1)) {
6713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6714 }
6715 arg1 = reinterpret_cast< wxRect * >(argp1);
6716 {
6717 PyThreadState* __tstate = wxPyBeginAllowThreads();
6718 result = ((wxRect const *)arg1)->GetTopLeft();
6719 wxPyEndAllowThreads(__tstate);
6720 if (PyErr_Occurred()) SWIG_fail;
6721 }
6722 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6723 return resultobj;
6724 fail:
6725 return NULL;
6726 }
6727
6728
6729 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6730 PyObject *resultobj = 0;
6731 wxRect *arg1 = (wxRect *) 0 ;
6732 wxPoint *arg2 = 0 ;
6733 void *argp1 = 0 ;
6734 int res1 = 0 ;
6735 wxPoint temp2 ;
6736 PyObject * obj0 = 0 ;
6737 PyObject * obj1 = 0 ;
6738 char * kwnames[] = {
6739 (char *) "self",(char *) "p", NULL
6740 };
6741
6742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6744 if (!SWIG_IsOK(res1)) {
6745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6746 }
6747 arg1 = reinterpret_cast< wxRect * >(argp1);
6748 {
6749 arg2 = &temp2;
6750 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6751 }
6752 {
6753 PyThreadState* __tstate = wxPyBeginAllowThreads();
6754 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6755 wxPyEndAllowThreads(__tstate);
6756 if (PyErr_Occurred()) SWIG_fail;
6757 }
6758 resultobj = SWIG_Py_Void();
6759 return resultobj;
6760 fail:
6761 return NULL;
6762 }
6763
6764
6765 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6766 PyObject *resultobj = 0;
6767 wxRect *arg1 = (wxRect *) 0 ;
6768 wxPoint result;
6769 void *argp1 = 0 ;
6770 int res1 = 0 ;
6771 PyObject *swig_obj[1] ;
6772
6773 if (!args) SWIG_fail;
6774 swig_obj[0] = args;
6775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6776 if (!SWIG_IsOK(res1)) {
6777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6778 }
6779 arg1 = reinterpret_cast< wxRect * >(argp1);
6780 {
6781 PyThreadState* __tstate = wxPyBeginAllowThreads();
6782 result = ((wxRect const *)arg1)->GetBottomRight();
6783 wxPyEndAllowThreads(__tstate);
6784 if (PyErr_Occurred()) SWIG_fail;
6785 }
6786 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6794 PyObject *resultobj = 0;
6795 wxRect *arg1 = (wxRect *) 0 ;
6796 wxPoint *arg2 = 0 ;
6797 void *argp1 = 0 ;
6798 int res1 = 0 ;
6799 wxPoint temp2 ;
6800 PyObject * obj0 = 0 ;
6801 PyObject * obj1 = 0 ;
6802 char * kwnames[] = {
6803 (char *) "self",(char *) "p", NULL
6804 };
6805
6806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6808 if (!SWIG_IsOK(res1)) {
6809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6810 }
6811 arg1 = reinterpret_cast< wxRect * >(argp1);
6812 {
6813 arg2 = &temp2;
6814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6815 }
6816 {
6817 PyThreadState* __tstate = wxPyBeginAllowThreads();
6818 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6819 wxPyEndAllowThreads(__tstate);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 resultobj = SWIG_Py_Void();
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6830 PyObject *resultobj = 0;
6831 wxRect *arg1 = (wxRect *) 0 ;
6832 int result;
6833 void *argp1 = 0 ;
6834 int res1 = 0 ;
6835 PyObject *swig_obj[1] ;
6836
6837 if (!args) SWIG_fail;
6838 swig_obj[0] = args;
6839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6840 if (!SWIG_IsOK(res1)) {
6841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6842 }
6843 arg1 = reinterpret_cast< wxRect * >(argp1);
6844 {
6845 PyThreadState* __tstate = wxPyBeginAllowThreads();
6846 result = (int)((wxRect const *)arg1)->GetLeft();
6847 wxPyEndAllowThreads(__tstate);
6848 if (PyErr_Occurred()) SWIG_fail;
6849 }
6850 resultobj = SWIG_From_int(static_cast< int >(result));
6851 return resultobj;
6852 fail:
6853 return NULL;
6854 }
6855
6856
6857 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6858 PyObject *resultobj = 0;
6859 wxRect *arg1 = (wxRect *) 0 ;
6860 int result;
6861 void *argp1 = 0 ;
6862 int res1 = 0 ;
6863 PyObject *swig_obj[1] ;
6864
6865 if (!args) SWIG_fail;
6866 swig_obj[0] = args;
6867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6868 if (!SWIG_IsOK(res1)) {
6869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6870 }
6871 arg1 = reinterpret_cast< wxRect * >(argp1);
6872 {
6873 PyThreadState* __tstate = wxPyBeginAllowThreads();
6874 result = (int)((wxRect const *)arg1)->GetTop();
6875 wxPyEndAllowThreads(__tstate);
6876 if (PyErr_Occurred()) SWIG_fail;
6877 }
6878 resultobj = SWIG_From_int(static_cast< int >(result));
6879 return resultobj;
6880 fail:
6881 return NULL;
6882 }
6883
6884
6885 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6886 PyObject *resultobj = 0;
6887 wxRect *arg1 = (wxRect *) 0 ;
6888 int result;
6889 void *argp1 = 0 ;
6890 int res1 = 0 ;
6891 PyObject *swig_obj[1] ;
6892
6893 if (!args) SWIG_fail;
6894 swig_obj[0] = args;
6895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6896 if (!SWIG_IsOK(res1)) {
6897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6898 }
6899 arg1 = reinterpret_cast< wxRect * >(argp1);
6900 {
6901 PyThreadState* __tstate = wxPyBeginAllowThreads();
6902 result = (int)((wxRect const *)arg1)->GetBottom();
6903 wxPyEndAllowThreads(__tstate);
6904 if (PyErr_Occurred()) SWIG_fail;
6905 }
6906 resultobj = SWIG_From_int(static_cast< int >(result));
6907 return resultobj;
6908 fail:
6909 return NULL;
6910 }
6911
6912
6913 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6914 PyObject *resultobj = 0;
6915 wxRect *arg1 = (wxRect *) 0 ;
6916 int result;
6917 void *argp1 = 0 ;
6918 int res1 = 0 ;
6919 PyObject *swig_obj[1] ;
6920
6921 if (!args) SWIG_fail;
6922 swig_obj[0] = args;
6923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6924 if (!SWIG_IsOK(res1)) {
6925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6926 }
6927 arg1 = reinterpret_cast< wxRect * >(argp1);
6928 {
6929 PyThreadState* __tstate = wxPyBeginAllowThreads();
6930 result = (int)((wxRect const *)arg1)->GetRight();
6931 wxPyEndAllowThreads(__tstate);
6932 if (PyErr_Occurred()) SWIG_fail;
6933 }
6934 resultobj = SWIG_From_int(static_cast< int >(result));
6935 return resultobj;
6936 fail:
6937 return NULL;
6938 }
6939
6940
6941 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6942 PyObject *resultobj = 0;
6943 wxRect *arg1 = (wxRect *) 0 ;
6944 int arg2 ;
6945 void *argp1 = 0 ;
6946 int res1 = 0 ;
6947 int val2 ;
6948 int ecode2 = 0 ;
6949 PyObject * obj0 = 0 ;
6950 PyObject * obj1 = 0 ;
6951 char * kwnames[] = {
6952 (char *) "self",(char *) "left", NULL
6953 };
6954
6955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6957 if (!SWIG_IsOK(res1)) {
6958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6959 }
6960 arg1 = reinterpret_cast< wxRect * >(argp1);
6961 ecode2 = SWIG_AsVal_int(obj1, &val2);
6962 if (!SWIG_IsOK(ecode2)) {
6963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6964 }
6965 arg2 = static_cast< int >(val2);
6966 {
6967 PyThreadState* __tstate = wxPyBeginAllowThreads();
6968 (arg1)->SetLeft(arg2);
6969 wxPyEndAllowThreads(__tstate);
6970 if (PyErr_Occurred()) SWIG_fail;
6971 }
6972 resultobj = SWIG_Py_Void();
6973 return resultobj;
6974 fail:
6975 return NULL;
6976 }
6977
6978
6979 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6980 PyObject *resultobj = 0;
6981 wxRect *arg1 = (wxRect *) 0 ;
6982 int arg2 ;
6983 void *argp1 = 0 ;
6984 int res1 = 0 ;
6985 int val2 ;
6986 int ecode2 = 0 ;
6987 PyObject * obj0 = 0 ;
6988 PyObject * obj1 = 0 ;
6989 char * kwnames[] = {
6990 (char *) "self",(char *) "right", NULL
6991 };
6992
6993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6995 if (!SWIG_IsOK(res1)) {
6996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6997 }
6998 arg1 = reinterpret_cast< wxRect * >(argp1);
6999 ecode2 = SWIG_AsVal_int(obj1, &val2);
7000 if (!SWIG_IsOK(ecode2)) {
7001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7002 }
7003 arg2 = static_cast< int >(val2);
7004 {
7005 PyThreadState* __tstate = wxPyBeginAllowThreads();
7006 (arg1)->SetRight(arg2);
7007 wxPyEndAllowThreads(__tstate);
7008 if (PyErr_Occurred()) SWIG_fail;
7009 }
7010 resultobj = SWIG_Py_Void();
7011 return resultobj;
7012 fail:
7013 return NULL;
7014 }
7015
7016
7017 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7018 PyObject *resultobj = 0;
7019 wxRect *arg1 = (wxRect *) 0 ;
7020 int arg2 ;
7021 void *argp1 = 0 ;
7022 int res1 = 0 ;
7023 int val2 ;
7024 int ecode2 = 0 ;
7025 PyObject * obj0 = 0 ;
7026 PyObject * obj1 = 0 ;
7027 char * kwnames[] = {
7028 (char *) "self",(char *) "top", NULL
7029 };
7030
7031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7033 if (!SWIG_IsOK(res1)) {
7034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7035 }
7036 arg1 = reinterpret_cast< wxRect * >(argp1);
7037 ecode2 = SWIG_AsVal_int(obj1, &val2);
7038 if (!SWIG_IsOK(ecode2)) {
7039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7040 }
7041 arg2 = static_cast< int >(val2);
7042 {
7043 PyThreadState* __tstate = wxPyBeginAllowThreads();
7044 (arg1)->SetTop(arg2);
7045 wxPyEndAllowThreads(__tstate);
7046 if (PyErr_Occurred()) SWIG_fail;
7047 }
7048 resultobj = SWIG_Py_Void();
7049 return resultobj;
7050 fail:
7051 return NULL;
7052 }
7053
7054
7055 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7056 PyObject *resultobj = 0;
7057 wxRect *arg1 = (wxRect *) 0 ;
7058 int arg2 ;
7059 void *argp1 = 0 ;
7060 int res1 = 0 ;
7061 int val2 ;
7062 int ecode2 = 0 ;
7063 PyObject * obj0 = 0 ;
7064 PyObject * obj1 = 0 ;
7065 char * kwnames[] = {
7066 (char *) "self",(char *) "bottom", NULL
7067 };
7068
7069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7071 if (!SWIG_IsOK(res1)) {
7072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7073 }
7074 arg1 = reinterpret_cast< wxRect * >(argp1);
7075 ecode2 = SWIG_AsVal_int(obj1, &val2);
7076 if (!SWIG_IsOK(ecode2)) {
7077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7078 }
7079 arg2 = static_cast< int >(val2);
7080 {
7081 PyThreadState* __tstate = wxPyBeginAllowThreads();
7082 (arg1)->SetBottom(arg2);
7083 wxPyEndAllowThreads(__tstate);
7084 if (PyErr_Occurred()) SWIG_fail;
7085 }
7086 resultobj = SWIG_Py_Void();
7087 return resultobj;
7088 fail:
7089 return NULL;
7090 }
7091
7092
7093 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7094 PyObject *resultobj = 0;
7095 wxRect *arg1 = (wxRect *) 0 ;
7096 int arg2 ;
7097 int arg3 ;
7098 wxRect *result = 0 ;
7099 void *argp1 = 0 ;
7100 int res1 = 0 ;
7101 int val2 ;
7102 int ecode2 = 0 ;
7103 int val3 ;
7104 int ecode3 = 0 ;
7105 PyObject * obj0 = 0 ;
7106 PyObject * obj1 = 0 ;
7107 PyObject * obj2 = 0 ;
7108 char * kwnames[] = {
7109 (char *) "self",(char *) "dx",(char *) "dy", NULL
7110 };
7111
7112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7114 if (!SWIG_IsOK(res1)) {
7115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7116 }
7117 arg1 = reinterpret_cast< wxRect * >(argp1);
7118 ecode2 = SWIG_AsVal_int(obj1, &val2);
7119 if (!SWIG_IsOK(ecode2)) {
7120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7121 }
7122 arg2 = static_cast< int >(val2);
7123 ecode3 = SWIG_AsVal_int(obj2, &val3);
7124 if (!SWIG_IsOK(ecode3)) {
7125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7126 }
7127 arg3 = static_cast< int >(val3);
7128 {
7129 PyThreadState* __tstate = wxPyBeginAllowThreads();
7130 {
7131 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7132 result = (wxRect *) &_result_ref;
7133 }
7134 wxPyEndAllowThreads(__tstate);
7135 if (PyErr_Occurred()) SWIG_fail;
7136 }
7137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7138 return resultobj;
7139 fail:
7140 return NULL;
7141 }
7142
7143
7144 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7145 PyObject *resultobj = 0;
7146 wxRect *arg1 = (wxRect *) 0 ;
7147 int arg2 ;
7148 int arg3 ;
7149 wxRect *result = 0 ;
7150 void *argp1 = 0 ;
7151 int res1 = 0 ;
7152 int val2 ;
7153 int ecode2 = 0 ;
7154 int val3 ;
7155 int ecode3 = 0 ;
7156 PyObject * obj0 = 0 ;
7157 PyObject * obj1 = 0 ;
7158 PyObject * obj2 = 0 ;
7159 char * kwnames[] = {
7160 (char *) "self",(char *) "dx",(char *) "dy", NULL
7161 };
7162
7163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7165 if (!SWIG_IsOK(res1)) {
7166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7167 }
7168 arg1 = reinterpret_cast< wxRect * >(argp1);
7169 ecode2 = SWIG_AsVal_int(obj1, &val2);
7170 if (!SWIG_IsOK(ecode2)) {
7171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7172 }
7173 arg2 = static_cast< int >(val2);
7174 ecode3 = SWIG_AsVal_int(obj2, &val3);
7175 if (!SWIG_IsOK(ecode3)) {
7176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7177 }
7178 arg3 = static_cast< int >(val3);
7179 {
7180 PyThreadState* __tstate = wxPyBeginAllowThreads();
7181 {
7182 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7183 result = (wxRect *) &_result_ref;
7184 }
7185 wxPyEndAllowThreads(__tstate);
7186 if (PyErr_Occurred()) SWIG_fail;
7187 }
7188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7189 return resultobj;
7190 fail:
7191 return NULL;
7192 }
7193
7194
7195 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7196 PyObject *resultobj = 0;
7197 wxRect *arg1 = (wxRect *) 0 ;
7198 int arg2 ;
7199 int arg3 ;
7200 void *argp1 = 0 ;
7201 int res1 = 0 ;
7202 int val2 ;
7203 int ecode2 = 0 ;
7204 int val3 ;
7205 int ecode3 = 0 ;
7206 PyObject * obj0 = 0 ;
7207 PyObject * obj1 = 0 ;
7208 PyObject * obj2 = 0 ;
7209 char * kwnames[] = {
7210 (char *) "self",(char *) "dx",(char *) "dy", NULL
7211 };
7212
7213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7215 if (!SWIG_IsOK(res1)) {
7216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7217 }
7218 arg1 = reinterpret_cast< wxRect * >(argp1);
7219 ecode2 = SWIG_AsVal_int(obj1, &val2);
7220 if (!SWIG_IsOK(ecode2)) {
7221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7222 }
7223 arg2 = static_cast< int >(val2);
7224 ecode3 = SWIG_AsVal_int(obj2, &val3);
7225 if (!SWIG_IsOK(ecode3)) {
7226 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7227 }
7228 arg3 = static_cast< int >(val3);
7229 {
7230 PyThreadState* __tstate = wxPyBeginAllowThreads();
7231 (arg1)->Offset(arg2,arg3);
7232 wxPyEndAllowThreads(__tstate);
7233 if (PyErr_Occurred()) SWIG_fail;
7234 }
7235 resultobj = SWIG_Py_Void();
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7243 PyObject *resultobj = 0;
7244 wxRect *arg1 = (wxRect *) 0 ;
7245 wxPoint *arg2 = 0 ;
7246 void *argp1 = 0 ;
7247 int res1 = 0 ;
7248 wxPoint temp2 ;
7249 PyObject * obj0 = 0 ;
7250 PyObject * obj1 = 0 ;
7251 char * kwnames[] = {
7252 (char *) "self",(char *) "pt", NULL
7253 };
7254
7255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7257 if (!SWIG_IsOK(res1)) {
7258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7259 }
7260 arg1 = reinterpret_cast< wxRect * >(argp1);
7261 {
7262 arg2 = &temp2;
7263 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7264 }
7265 {
7266 PyThreadState* __tstate = wxPyBeginAllowThreads();
7267 (arg1)->Offset((wxPoint const &)*arg2);
7268 wxPyEndAllowThreads(__tstate);
7269 if (PyErr_Occurred()) SWIG_fail;
7270 }
7271 resultobj = SWIG_Py_Void();
7272 return resultobj;
7273 fail:
7274 return NULL;
7275 }
7276
7277
7278 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7279 PyObject *resultobj = 0;
7280 wxRect *arg1 = (wxRect *) 0 ;
7281 wxRect *arg2 = 0 ;
7282 wxRect result;
7283 void *argp1 = 0 ;
7284 int res1 = 0 ;
7285 wxRect temp2 ;
7286 PyObject * obj0 = 0 ;
7287 PyObject * obj1 = 0 ;
7288 char * kwnames[] = {
7289 (char *) "self",(char *) "rect", NULL
7290 };
7291
7292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7294 if (!SWIG_IsOK(res1)) {
7295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7296 }
7297 arg1 = reinterpret_cast< wxRect * >(argp1);
7298 {
7299 arg2 = &temp2;
7300 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7301 }
7302 {
7303 PyThreadState* __tstate = wxPyBeginAllowThreads();
7304 result = (arg1)->Intersect((wxRect const &)*arg2);
7305 wxPyEndAllowThreads(__tstate);
7306 if (PyErr_Occurred()) SWIG_fail;
7307 }
7308 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7309 return resultobj;
7310 fail:
7311 return NULL;
7312 }
7313
7314
7315 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7316 PyObject *resultobj = 0;
7317 wxRect *arg1 = (wxRect *) 0 ;
7318 wxRect *arg2 = 0 ;
7319 wxRect result;
7320 void *argp1 = 0 ;
7321 int res1 = 0 ;
7322 wxRect temp2 ;
7323 PyObject * obj0 = 0 ;
7324 PyObject * obj1 = 0 ;
7325 char * kwnames[] = {
7326 (char *) "self",(char *) "rect", NULL
7327 };
7328
7329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7331 if (!SWIG_IsOK(res1)) {
7332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7333 }
7334 arg1 = reinterpret_cast< wxRect * >(argp1);
7335 {
7336 arg2 = &temp2;
7337 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7338 }
7339 {
7340 PyThreadState* __tstate = wxPyBeginAllowThreads();
7341 result = (arg1)->Union((wxRect const &)*arg2);
7342 wxPyEndAllowThreads(__tstate);
7343 if (PyErr_Occurred()) SWIG_fail;
7344 }
7345 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7346 return resultobj;
7347 fail:
7348 return NULL;
7349 }
7350
7351
7352 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7353 PyObject *resultobj = 0;
7354 wxRect *arg1 = (wxRect *) 0 ;
7355 wxRect *arg2 = 0 ;
7356 wxRect result;
7357 void *argp1 = 0 ;
7358 int res1 = 0 ;
7359 wxRect temp2 ;
7360 PyObject * obj0 = 0 ;
7361 PyObject * obj1 = 0 ;
7362 char * kwnames[] = {
7363 (char *) "self",(char *) "rect", NULL
7364 };
7365
7366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7368 if (!SWIG_IsOK(res1)) {
7369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7370 }
7371 arg1 = reinterpret_cast< wxRect * >(argp1);
7372 {
7373 arg2 = &temp2;
7374 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7375 }
7376 {
7377 PyThreadState* __tstate = wxPyBeginAllowThreads();
7378 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7379 wxPyEndAllowThreads(__tstate);
7380 if (PyErr_Occurred()) SWIG_fail;
7381 }
7382 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7383 return resultobj;
7384 fail:
7385 return NULL;
7386 }
7387
7388
7389 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7390 PyObject *resultobj = 0;
7391 wxRect *arg1 = (wxRect *) 0 ;
7392 wxRect *arg2 = 0 ;
7393 wxRect *result = 0 ;
7394 void *argp1 = 0 ;
7395 int res1 = 0 ;
7396 wxRect temp2 ;
7397 PyObject * obj0 = 0 ;
7398 PyObject * obj1 = 0 ;
7399 char * kwnames[] = {
7400 (char *) "self",(char *) "rect", NULL
7401 };
7402
7403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7405 if (!SWIG_IsOK(res1)) {
7406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7407 }
7408 arg1 = reinterpret_cast< wxRect * >(argp1);
7409 {
7410 arg2 = &temp2;
7411 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7412 }
7413 {
7414 PyThreadState* __tstate = wxPyBeginAllowThreads();
7415 {
7416 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7417 result = (wxRect *) &_result_ref;
7418 }
7419 wxPyEndAllowThreads(__tstate);
7420 if (PyErr_Occurred()) SWIG_fail;
7421 }
7422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7423 return resultobj;
7424 fail:
7425 return NULL;
7426 }
7427
7428
7429 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7430 PyObject *resultobj = 0;
7431 wxRect *arg1 = (wxRect *) 0 ;
7432 PyObject *arg2 = (PyObject *) 0 ;
7433 bool result;
7434 void *argp1 = 0 ;
7435 int res1 = 0 ;
7436 PyObject * obj0 = 0 ;
7437 PyObject * obj1 = 0 ;
7438 char * kwnames[] = {
7439 (char *) "self",(char *) "other", NULL
7440 };
7441
7442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7444 if (!SWIG_IsOK(res1)) {
7445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7446 }
7447 arg1 = reinterpret_cast< wxRect * >(argp1);
7448 arg2 = obj1;
7449 {
7450 result = (bool)wxRect___eq__(arg1,arg2);
7451 if (PyErr_Occurred()) SWIG_fail;
7452 }
7453 {
7454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7455 }
7456 return resultobj;
7457 fail:
7458 return NULL;
7459 }
7460
7461
7462 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7463 PyObject *resultobj = 0;
7464 wxRect *arg1 = (wxRect *) 0 ;
7465 PyObject *arg2 = (PyObject *) 0 ;
7466 bool result;
7467 void *argp1 = 0 ;
7468 int res1 = 0 ;
7469 PyObject * obj0 = 0 ;
7470 PyObject * obj1 = 0 ;
7471 char * kwnames[] = {
7472 (char *) "self",(char *) "other", NULL
7473 };
7474
7475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7477 if (!SWIG_IsOK(res1)) {
7478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7479 }
7480 arg1 = reinterpret_cast< wxRect * >(argp1);
7481 arg2 = obj1;
7482 {
7483 result = (bool)wxRect___ne__(arg1,arg2);
7484 if (PyErr_Occurred()) SWIG_fail;
7485 }
7486 {
7487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7488 }
7489 return resultobj;
7490 fail:
7491 return NULL;
7492 }
7493
7494
7495 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7496 PyObject *resultobj = 0;
7497 wxRect *arg1 = (wxRect *) 0 ;
7498 int arg2 ;
7499 int arg3 ;
7500 bool result;
7501 void *argp1 = 0 ;
7502 int res1 = 0 ;
7503 int val2 ;
7504 int ecode2 = 0 ;
7505 int val3 ;
7506 int ecode3 = 0 ;
7507 PyObject * obj0 = 0 ;
7508 PyObject * obj1 = 0 ;
7509 PyObject * obj2 = 0 ;
7510 char * kwnames[] = {
7511 (char *) "self",(char *) "x",(char *) "y", NULL
7512 };
7513
7514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7516 if (!SWIG_IsOK(res1)) {
7517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7518 }
7519 arg1 = reinterpret_cast< wxRect * >(argp1);
7520 ecode2 = SWIG_AsVal_int(obj1, &val2);
7521 if (!SWIG_IsOK(ecode2)) {
7522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7523 }
7524 arg2 = static_cast< int >(val2);
7525 ecode3 = SWIG_AsVal_int(obj2, &val3);
7526 if (!SWIG_IsOK(ecode3)) {
7527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7528 }
7529 arg3 = static_cast< int >(val3);
7530 {
7531 PyThreadState* __tstate = wxPyBeginAllowThreads();
7532 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7533 wxPyEndAllowThreads(__tstate);
7534 if (PyErr_Occurred()) SWIG_fail;
7535 }
7536 {
7537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7538 }
7539 return resultobj;
7540 fail:
7541 return NULL;
7542 }
7543
7544
7545 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7546 PyObject *resultobj = 0;
7547 wxRect *arg1 = (wxRect *) 0 ;
7548 wxPoint *arg2 = 0 ;
7549 bool result;
7550 void *argp1 = 0 ;
7551 int res1 = 0 ;
7552 wxPoint temp2 ;
7553 PyObject * obj0 = 0 ;
7554 PyObject * obj1 = 0 ;
7555 char * kwnames[] = {
7556 (char *) "self",(char *) "pt", NULL
7557 };
7558
7559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7561 if (!SWIG_IsOK(res1)) {
7562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7563 }
7564 arg1 = reinterpret_cast< wxRect * >(argp1);
7565 {
7566 arg2 = &temp2;
7567 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7568 }
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7572 wxPyEndAllowThreads(__tstate);
7573 if (PyErr_Occurred()) SWIG_fail;
7574 }
7575 {
7576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7577 }
7578 return resultobj;
7579 fail:
7580 return NULL;
7581 }
7582
7583
7584 SWIGINTERN PyObject *_wrap_Rect_InsideRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7585 PyObject *resultobj = 0;
7586 wxRect *arg1 = (wxRect *) 0 ;
7587 wxRect *arg2 = 0 ;
7588 bool result;
7589 void *argp1 = 0 ;
7590 int res1 = 0 ;
7591 wxRect temp2 ;
7592 PyObject * obj0 = 0 ;
7593 PyObject * obj1 = 0 ;
7594 char * kwnames[] = {
7595 (char *) "self",(char *) "rect", NULL
7596 };
7597
7598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_InsideRect",kwnames,&obj0,&obj1)) SWIG_fail;
7599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7600 if (!SWIG_IsOK(res1)) {
7601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7602 }
7603 arg1 = reinterpret_cast< wxRect * >(argp1);
7604 {
7605 arg2 = &temp2;
7606 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7607 }
7608 {
7609 PyThreadState* __tstate = wxPyBeginAllowThreads();
7610 result = (bool)((wxRect const *)arg1)->Inside((wxRect const &)*arg2);
7611 wxPyEndAllowThreads(__tstate);
7612 if (PyErr_Occurred()) SWIG_fail;
7613 }
7614 {
7615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7616 }
7617 return resultobj;
7618 fail:
7619 return NULL;
7620 }
7621
7622
7623 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7624 PyObject *resultobj = 0;
7625 wxRect *arg1 = (wxRect *) 0 ;
7626 wxRect *arg2 = 0 ;
7627 bool result;
7628 void *argp1 = 0 ;
7629 int res1 = 0 ;
7630 wxRect temp2 ;
7631 PyObject * obj0 = 0 ;
7632 PyObject * obj1 = 0 ;
7633 char * kwnames[] = {
7634 (char *) "self",(char *) "rect", NULL
7635 };
7636
7637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7639 if (!SWIG_IsOK(res1)) {
7640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7641 }
7642 arg1 = reinterpret_cast< wxRect * >(argp1);
7643 {
7644 arg2 = &temp2;
7645 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7646 }
7647 {
7648 PyThreadState* __tstate = wxPyBeginAllowThreads();
7649 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7650 wxPyEndAllowThreads(__tstate);
7651 if (PyErr_Occurred()) SWIG_fail;
7652 }
7653 {
7654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7655 }
7656 return resultobj;
7657 fail:
7658 return NULL;
7659 }
7660
7661
7662 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7663 PyObject *resultobj = 0;
7664 wxRect *arg1 = (wxRect *) 0 ;
7665 wxRect *arg2 = 0 ;
7666 int arg3 = (int) wxBOTH ;
7667 wxRect result;
7668 void *argp1 = 0 ;
7669 int res1 = 0 ;
7670 wxRect temp2 ;
7671 int val3 ;
7672 int ecode3 = 0 ;
7673 PyObject * obj0 = 0 ;
7674 PyObject * obj1 = 0 ;
7675 PyObject * obj2 = 0 ;
7676 char * kwnames[] = {
7677 (char *) "self",(char *) "r",(char *) "dir", NULL
7678 };
7679
7680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7682 if (!SWIG_IsOK(res1)) {
7683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7684 }
7685 arg1 = reinterpret_cast< wxRect * >(argp1);
7686 {
7687 arg2 = &temp2;
7688 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7689 }
7690 if (obj2) {
7691 ecode3 = SWIG_AsVal_int(obj2, &val3);
7692 if (!SWIG_IsOK(ecode3)) {
7693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7694 }
7695 arg3 = static_cast< int >(val3);
7696 }
7697 {
7698 PyThreadState* __tstate = wxPyBeginAllowThreads();
7699 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7700 wxPyEndAllowThreads(__tstate);
7701 if (PyErr_Occurred()) SWIG_fail;
7702 }
7703 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7704 return resultobj;
7705 fail:
7706 return NULL;
7707 }
7708
7709
7710 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7711 PyObject *resultobj = 0;
7712 wxRect *arg1 = (wxRect *) 0 ;
7713 int arg2 ;
7714 void *argp1 = 0 ;
7715 int res1 = 0 ;
7716 int val2 ;
7717 int ecode2 = 0 ;
7718 PyObject *swig_obj[2] ;
7719
7720 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7722 if (!SWIG_IsOK(res1)) {
7723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7724 }
7725 arg1 = reinterpret_cast< wxRect * >(argp1);
7726 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7727 if (!SWIG_IsOK(ecode2)) {
7728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7729 }
7730 arg2 = static_cast< int >(val2);
7731 if (arg1) (arg1)->x = arg2;
7732
7733 resultobj = SWIG_Py_Void();
7734 return resultobj;
7735 fail:
7736 return NULL;
7737 }
7738
7739
7740 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7741 PyObject *resultobj = 0;
7742 wxRect *arg1 = (wxRect *) 0 ;
7743 int result;
7744 void *argp1 = 0 ;
7745 int res1 = 0 ;
7746 PyObject *swig_obj[1] ;
7747
7748 if (!args) SWIG_fail;
7749 swig_obj[0] = args;
7750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7751 if (!SWIG_IsOK(res1)) {
7752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7753 }
7754 arg1 = reinterpret_cast< wxRect * >(argp1);
7755 result = (int) ((arg1)->x);
7756 resultobj = SWIG_From_int(static_cast< int >(result));
7757 return resultobj;
7758 fail:
7759 return NULL;
7760 }
7761
7762
7763 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7764 PyObject *resultobj = 0;
7765 wxRect *arg1 = (wxRect *) 0 ;
7766 int arg2 ;
7767 void *argp1 = 0 ;
7768 int res1 = 0 ;
7769 int val2 ;
7770 int ecode2 = 0 ;
7771 PyObject *swig_obj[2] ;
7772
7773 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7775 if (!SWIG_IsOK(res1)) {
7776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7777 }
7778 arg1 = reinterpret_cast< wxRect * >(argp1);
7779 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7780 if (!SWIG_IsOK(ecode2)) {
7781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7782 }
7783 arg2 = static_cast< int >(val2);
7784 if (arg1) (arg1)->y = arg2;
7785
7786 resultobj = SWIG_Py_Void();
7787 return resultobj;
7788 fail:
7789 return NULL;
7790 }
7791
7792
7793 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7794 PyObject *resultobj = 0;
7795 wxRect *arg1 = (wxRect *) 0 ;
7796 int result;
7797 void *argp1 = 0 ;
7798 int res1 = 0 ;
7799 PyObject *swig_obj[1] ;
7800
7801 if (!args) SWIG_fail;
7802 swig_obj[0] = args;
7803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7804 if (!SWIG_IsOK(res1)) {
7805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7806 }
7807 arg1 = reinterpret_cast< wxRect * >(argp1);
7808 result = (int) ((arg1)->y);
7809 resultobj = SWIG_From_int(static_cast< int >(result));
7810 return resultobj;
7811 fail:
7812 return NULL;
7813 }
7814
7815
7816 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7817 PyObject *resultobj = 0;
7818 wxRect *arg1 = (wxRect *) 0 ;
7819 int arg2 ;
7820 void *argp1 = 0 ;
7821 int res1 = 0 ;
7822 int val2 ;
7823 int ecode2 = 0 ;
7824 PyObject *swig_obj[2] ;
7825
7826 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7828 if (!SWIG_IsOK(res1)) {
7829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7830 }
7831 arg1 = reinterpret_cast< wxRect * >(argp1);
7832 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7833 if (!SWIG_IsOK(ecode2)) {
7834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7835 }
7836 arg2 = static_cast< int >(val2);
7837 if (arg1) (arg1)->width = arg2;
7838
7839 resultobj = SWIG_Py_Void();
7840 return resultobj;
7841 fail:
7842 return NULL;
7843 }
7844
7845
7846 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7847 PyObject *resultobj = 0;
7848 wxRect *arg1 = (wxRect *) 0 ;
7849 int result;
7850 void *argp1 = 0 ;
7851 int res1 = 0 ;
7852 PyObject *swig_obj[1] ;
7853
7854 if (!args) SWIG_fail;
7855 swig_obj[0] = args;
7856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7857 if (!SWIG_IsOK(res1)) {
7858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7859 }
7860 arg1 = reinterpret_cast< wxRect * >(argp1);
7861 result = (int) ((arg1)->width);
7862 resultobj = SWIG_From_int(static_cast< int >(result));
7863 return resultobj;
7864 fail:
7865 return NULL;
7866 }
7867
7868
7869 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7870 PyObject *resultobj = 0;
7871 wxRect *arg1 = (wxRect *) 0 ;
7872 int arg2 ;
7873 void *argp1 = 0 ;
7874 int res1 = 0 ;
7875 int val2 ;
7876 int ecode2 = 0 ;
7877 PyObject *swig_obj[2] ;
7878
7879 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7881 if (!SWIG_IsOK(res1)) {
7882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7883 }
7884 arg1 = reinterpret_cast< wxRect * >(argp1);
7885 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7886 if (!SWIG_IsOK(ecode2)) {
7887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7888 }
7889 arg2 = static_cast< int >(val2);
7890 if (arg1) (arg1)->height = arg2;
7891
7892 resultobj = SWIG_Py_Void();
7893 return resultobj;
7894 fail:
7895 return NULL;
7896 }
7897
7898
7899 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7900 PyObject *resultobj = 0;
7901 wxRect *arg1 = (wxRect *) 0 ;
7902 int result;
7903 void *argp1 = 0 ;
7904 int res1 = 0 ;
7905 PyObject *swig_obj[1] ;
7906
7907 if (!args) SWIG_fail;
7908 swig_obj[0] = args;
7909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7910 if (!SWIG_IsOK(res1)) {
7911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7912 }
7913 arg1 = reinterpret_cast< wxRect * >(argp1);
7914 result = (int) ((arg1)->height);
7915 resultobj = SWIG_From_int(static_cast< int >(result));
7916 return resultobj;
7917 fail:
7918 return NULL;
7919 }
7920
7921
7922 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7923 PyObject *resultobj = 0;
7924 wxRect *arg1 = (wxRect *) 0 ;
7925 int arg2 = (int) 0 ;
7926 int arg3 = (int) 0 ;
7927 int arg4 = (int) 0 ;
7928 int arg5 = (int) 0 ;
7929 void *argp1 = 0 ;
7930 int res1 = 0 ;
7931 int val2 ;
7932 int ecode2 = 0 ;
7933 int val3 ;
7934 int ecode3 = 0 ;
7935 int val4 ;
7936 int ecode4 = 0 ;
7937 int val5 ;
7938 int ecode5 = 0 ;
7939 PyObject * obj0 = 0 ;
7940 PyObject * obj1 = 0 ;
7941 PyObject * obj2 = 0 ;
7942 PyObject * obj3 = 0 ;
7943 PyObject * obj4 = 0 ;
7944 char * kwnames[] = {
7945 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7946 };
7947
7948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7950 if (!SWIG_IsOK(res1)) {
7951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7952 }
7953 arg1 = reinterpret_cast< wxRect * >(argp1);
7954 if (obj1) {
7955 ecode2 = SWIG_AsVal_int(obj1, &val2);
7956 if (!SWIG_IsOK(ecode2)) {
7957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7958 }
7959 arg2 = static_cast< int >(val2);
7960 }
7961 if (obj2) {
7962 ecode3 = SWIG_AsVal_int(obj2, &val3);
7963 if (!SWIG_IsOK(ecode3)) {
7964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7965 }
7966 arg3 = static_cast< int >(val3);
7967 }
7968 if (obj3) {
7969 ecode4 = SWIG_AsVal_int(obj3, &val4);
7970 if (!SWIG_IsOK(ecode4)) {
7971 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7972 }
7973 arg4 = static_cast< int >(val4);
7974 }
7975 if (obj4) {
7976 ecode5 = SWIG_AsVal_int(obj4, &val5);
7977 if (!SWIG_IsOK(ecode5)) {
7978 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7979 }
7980 arg5 = static_cast< int >(val5);
7981 }
7982 {
7983 PyThreadState* __tstate = wxPyBeginAllowThreads();
7984 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7985 wxPyEndAllowThreads(__tstate);
7986 if (PyErr_Occurred()) SWIG_fail;
7987 }
7988 resultobj = SWIG_Py_Void();
7989 return resultobj;
7990 fail:
7991 return NULL;
7992 }
7993
7994
7995 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7996 PyObject *resultobj = 0;
7997 wxRect *arg1 = (wxRect *) 0 ;
7998 PyObject *result = 0 ;
7999 void *argp1 = 0 ;
8000 int res1 = 0 ;
8001 PyObject *swig_obj[1] ;
8002
8003 if (!args) SWIG_fail;
8004 swig_obj[0] = args;
8005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8006 if (!SWIG_IsOK(res1)) {
8007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8008 }
8009 arg1 = reinterpret_cast< wxRect * >(argp1);
8010 {
8011 PyThreadState* __tstate = wxPyBeginAllowThreads();
8012 result = (PyObject *)wxRect_Get(arg1);
8013 wxPyEndAllowThreads(__tstate);
8014 if (PyErr_Occurred()) SWIG_fail;
8015 }
8016 resultobj = result;
8017 return resultobj;
8018 fail:
8019 return NULL;
8020 }
8021
8022
8023 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8024 PyObject *obj;
8025 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8026 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8027 return SWIG_Py_Void();
8028 }
8029
8030 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8031 return SWIG_Python_InitShadowInstance(args);
8032 }
8033
8034 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8035 PyObject *resultobj = 0;
8036 wxRect *arg1 = (wxRect *) 0 ;
8037 wxRect *arg2 = (wxRect *) 0 ;
8038 PyObject *result = 0 ;
8039 void *argp1 = 0 ;
8040 int res1 = 0 ;
8041 void *argp2 = 0 ;
8042 int res2 = 0 ;
8043 PyObject * obj0 = 0 ;
8044 PyObject * obj1 = 0 ;
8045 char * kwnames[] = {
8046 (char *) "r1",(char *) "r2", NULL
8047 };
8048
8049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8051 if (!SWIG_IsOK(res1)) {
8052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8053 }
8054 arg1 = reinterpret_cast< wxRect * >(argp1);
8055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8056 if (!SWIG_IsOK(res2)) {
8057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8058 }
8059 arg2 = reinterpret_cast< wxRect * >(argp2);
8060 {
8061 if (!wxPyCheckForApp()) SWIG_fail;
8062 PyThreadState* __tstate = wxPyBeginAllowThreads();
8063 result = (PyObject *)wxIntersectRect(arg1,arg2);
8064 wxPyEndAllowThreads(__tstate);
8065 if (PyErr_Occurred()) SWIG_fail;
8066 }
8067 resultobj = result;
8068 return resultobj;
8069 fail:
8070 return NULL;
8071 }
8072
8073
8074 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8075 PyObject *resultobj = 0;
8076 double arg1 = (double) 0.0 ;
8077 double arg2 = (double) 0.0 ;
8078 wxPoint2D *result = 0 ;
8079 double val1 ;
8080 int ecode1 = 0 ;
8081 double val2 ;
8082 int ecode2 = 0 ;
8083 PyObject * obj0 = 0 ;
8084 PyObject * obj1 = 0 ;
8085 char * kwnames[] = {
8086 (char *) "x",(char *) "y", NULL
8087 };
8088
8089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8090 if (obj0) {
8091 ecode1 = SWIG_AsVal_double(obj0, &val1);
8092 if (!SWIG_IsOK(ecode1)) {
8093 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8094 }
8095 arg1 = static_cast< double >(val1);
8096 }
8097 if (obj1) {
8098 ecode2 = SWIG_AsVal_double(obj1, &val2);
8099 if (!SWIG_IsOK(ecode2)) {
8100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8101 }
8102 arg2 = static_cast< double >(val2);
8103 }
8104 {
8105 PyThreadState* __tstate = wxPyBeginAllowThreads();
8106 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8107 wxPyEndAllowThreads(__tstate);
8108 if (PyErr_Occurred()) SWIG_fail;
8109 }
8110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8111 return resultobj;
8112 fail:
8113 return NULL;
8114 }
8115
8116
8117 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8118 PyObject *resultobj = 0;
8119 wxPoint2D *arg1 = 0 ;
8120 wxPoint2D *result = 0 ;
8121 wxPoint2D temp1 ;
8122 PyObject * obj0 = 0 ;
8123 char * kwnames[] = {
8124 (char *) "pt", NULL
8125 };
8126
8127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8128 {
8129 arg1 = &temp1;
8130 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8131 }
8132 {
8133 PyThreadState* __tstate = wxPyBeginAllowThreads();
8134 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8135 wxPyEndAllowThreads(__tstate);
8136 if (PyErr_Occurred()) SWIG_fail;
8137 }
8138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8146 PyObject *resultobj = 0;
8147 wxPoint *arg1 = 0 ;
8148 wxPoint2D *result = 0 ;
8149 wxPoint temp1 ;
8150 PyObject * obj0 = 0 ;
8151 char * kwnames[] = {
8152 (char *) "pt", NULL
8153 };
8154
8155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8156 {
8157 arg1 = &temp1;
8158 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8159 }
8160 {
8161 PyThreadState* __tstate = wxPyBeginAllowThreads();
8162 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8163 wxPyEndAllowThreads(__tstate);
8164 if (PyErr_Occurred()) SWIG_fail;
8165 }
8166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8167 return resultobj;
8168 fail:
8169 return NULL;
8170 }
8171
8172
8173 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8174 PyObject *resultobj = 0;
8175 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8176 int *arg2 = (int *) 0 ;
8177 int *arg3 = (int *) 0 ;
8178 void *argp1 = 0 ;
8179 int res1 = 0 ;
8180 int temp2 ;
8181 int res2 = SWIG_TMPOBJ ;
8182 int temp3 ;
8183 int res3 = SWIG_TMPOBJ ;
8184 PyObject *swig_obj[1] ;
8185
8186 arg2 = &temp2;
8187 arg3 = &temp3;
8188 if (!args) SWIG_fail;
8189 swig_obj[0] = args;
8190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8191 if (!SWIG_IsOK(res1)) {
8192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8193 }
8194 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8195 {
8196 PyThreadState* __tstate = wxPyBeginAllowThreads();
8197 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 resultobj = SWIG_Py_Void();
8202 if (SWIG_IsTmpObj(res2)) {
8203 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8204 } else {
8205 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8206 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8207 }
8208 if (SWIG_IsTmpObj(res3)) {
8209 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8210 } else {
8211 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8212 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8213 }
8214 return resultobj;
8215 fail:
8216 return NULL;
8217 }
8218
8219
8220 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8221 PyObject *resultobj = 0;
8222 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8223 int *arg2 = (int *) 0 ;
8224 int *arg3 = (int *) 0 ;
8225 void *argp1 = 0 ;
8226 int res1 = 0 ;
8227 int temp2 ;
8228 int res2 = SWIG_TMPOBJ ;
8229 int temp3 ;
8230 int res3 = SWIG_TMPOBJ ;
8231 PyObject *swig_obj[1] ;
8232
8233 arg2 = &temp2;
8234 arg3 = &temp3;
8235 if (!args) SWIG_fail;
8236 swig_obj[0] = args;
8237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8238 if (!SWIG_IsOK(res1)) {
8239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8240 }
8241 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8242 {
8243 PyThreadState* __tstate = wxPyBeginAllowThreads();
8244 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8245 wxPyEndAllowThreads(__tstate);
8246 if (PyErr_Occurred()) SWIG_fail;
8247 }
8248 resultobj = SWIG_Py_Void();
8249 if (SWIG_IsTmpObj(res2)) {
8250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8251 } else {
8252 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8254 }
8255 if (SWIG_IsTmpObj(res3)) {
8256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8257 } else {
8258 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8259 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8260 }
8261 return resultobj;
8262 fail:
8263 return NULL;
8264 }
8265
8266
8267 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8268 PyObject *resultobj = 0;
8269 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8270 double result;
8271 void *argp1 = 0 ;
8272 int res1 = 0 ;
8273 PyObject *swig_obj[1] ;
8274
8275 if (!args) SWIG_fail;
8276 swig_obj[0] = args;
8277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8278 if (!SWIG_IsOK(res1)) {
8279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8280 }
8281 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8282 {
8283 PyThreadState* __tstate = wxPyBeginAllowThreads();
8284 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 resultobj = SWIG_From_double(static_cast< double >(result));
8289 return resultobj;
8290 fail:
8291 return NULL;
8292 }
8293
8294
8295 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8296 PyObject *resultobj = 0;
8297 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8298 double result;
8299 void *argp1 = 0 ;
8300 int res1 = 0 ;
8301 PyObject *swig_obj[1] ;
8302
8303 if (!args) SWIG_fail;
8304 swig_obj[0] = args;
8305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8306 if (!SWIG_IsOK(res1)) {
8307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8308 }
8309 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8310 {
8311 PyThreadState* __tstate = wxPyBeginAllowThreads();
8312 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8313 wxPyEndAllowThreads(__tstate);
8314 if (PyErr_Occurred()) SWIG_fail;
8315 }
8316 resultobj = SWIG_From_double(static_cast< double >(result));
8317 return resultobj;
8318 fail:
8319 return NULL;
8320 }
8321
8322
8323 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8324 PyObject *resultobj = 0;
8325 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8326 double arg2 ;
8327 void *argp1 = 0 ;
8328 int res1 = 0 ;
8329 double val2 ;
8330 int ecode2 = 0 ;
8331 PyObject * obj0 = 0 ;
8332 PyObject * obj1 = 0 ;
8333 char * kwnames[] = {
8334 (char *) "self",(char *) "length", NULL
8335 };
8336
8337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8339 if (!SWIG_IsOK(res1)) {
8340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8341 }
8342 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8343 ecode2 = SWIG_AsVal_double(obj1, &val2);
8344 if (!SWIG_IsOK(ecode2)) {
8345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8346 }
8347 arg2 = static_cast< double >(val2);
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 (arg1)->SetVectorLength(arg2);
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_Py_Void();
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj = 0;
8363 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8364 double arg2 ;
8365 void *argp1 = 0 ;
8366 int res1 = 0 ;
8367 double val2 ;
8368 int ecode2 = 0 ;
8369 PyObject * obj0 = 0 ;
8370 PyObject * obj1 = 0 ;
8371 char * kwnames[] = {
8372 (char *) "self",(char *) "degrees", NULL
8373 };
8374
8375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8377 if (!SWIG_IsOK(res1)) {
8378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8379 }
8380 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8381 ecode2 = SWIG_AsVal_double(obj1, &val2);
8382 if (!SWIG_IsOK(ecode2)) {
8383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8384 }
8385 arg2 = static_cast< double >(val2);
8386 {
8387 PyThreadState* __tstate = wxPyBeginAllowThreads();
8388 (arg1)->SetVectorAngle(arg2);
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 resultobj = SWIG_Py_Void();
8393 return resultobj;
8394 fail:
8395 return NULL;
8396 }
8397
8398
8399 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8400 PyObject *resultobj = 0;
8401 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8402 wxPoint2D *arg2 = 0 ;
8403 double result;
8404 void *argp1 = 0 ;
8405 int res1 = 0 ;
8406 wxPoint2D temp2 ;
8407 PyObject * obj0 = 0 ;
8408 PyObject * obj1 = 0 ;
8409 char * kwnames[] = {
8410 (char *) "self",(char *) "pt", NULL
8411 };
8412
8413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8415 if (!SWIG_IsOK(res1)) {
8416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8417 }
8418 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8419 {
8420 arg2 = &temp2;
8421 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8422 }
8423 {
8424 PyThreadState* __tstate = wxPyBeginAllowThreads();
8425 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8426 wxPyEndAllowThreads(__tstate);
8427 if (PyErr_Occurred()) SWIG_fail;
8428 }
8429 resultobj = SWIG_From_double(static_cast< double >(result));
8430 return resultobj;
8431 fail:
8432 return NULL;
8433 }
8434
8435
8436 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8437 PyObject *resultobj = 0;
8438 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8439 wxPoint2D *arg2 = 0 ;
8440 double result;
8441 void *argp1 = 0 ;
8442 int res1 = 0 ;
8443 wxPoint2D temp2 ;
8444 PyObject * obj0 = 0 ;
8445 PyObject * obj1 = 0 ;
8446 char * kwnames[] = {
8447 (char *) "self",(char *) "pt", NULL
8448 };
8449
8450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8452 if (!SWIG_IsOK(res1)) {
8453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8454 }
8455 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8456 {
8457 arg2 = &temp2;
8458 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8459 }
8460 {
8461 PyThreadState* __tstate = wxPyBeginAllowThreads();
8462 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8463 wxPyEndAllowThreads(__tstate);
8464 if (PyErr_Occurred()) SWIG_fail;
8465 }
8466 resultobj = SWIG_From_double(static_cast< double >(result));
8467 return resultobj;
8468 fail:
8469 return NULL;
8470 }
8471
8472
8473 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8474 PyObject *resultobj = 0;
8475 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8476 wxPoint2D *arg2 = 0 ;
8477 double result;
8478 void *argp1 = 0 ;
8479 int res1 = 0 ;
8480 wxPoint2D temp2 ;
8481 PyObject * obj0 = 0 ;
8482 PyObject * obj1 = 0 ;
8483 char * kwnames[] = {
8484 (char *) "self",(char *) "vec", NULL
8485 };
8486
8487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8489 if (!SWIG_IsOK(res1)) {
8490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8491 }
8492 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8493 {
8494 arg2 = &temp2;
8495 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8496 }
8497 {
8498 PyThreadState* __tstate = wxPyBeginAllowThreads();
8499 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8500 wxPyEndAllowThreads(__tstate);
8501 if (PyErr_Occurred()) SWIG_fail;
8502 }
8503 resultobj = SWIG_From_double(static_cast< double >(result));
8504 return resultobj;
8505 fail:
8506 return NULL;
8507 }
8508
8509
8510 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8511 PyObject *resultobj = 0;
8512 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8513 wxPoint2D *arg2 = 0 ;
8514 double result;
8515 void *argp1 = 0 ;
8516 int res1 = 0 ;
8517 wxPoint2D temp2 ;
8518 PyObject * obj0 = 0 ;
8519 PyObject * obj1 = 0 ;
8520 char * kwnames[] = {
8521 (char *) "self",(char *) "vec", NULL
8522 };
8523
8524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8526 if (!SWIG_IsOK(res1)) {
8527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8528 }
8529 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8530 {
8531 arg2 = &temp2;
8532 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8533 }
8534 {
8535 PyThreadState* __tstate = wxPyBeginAllowThreads();
8536 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8537 wxPyEndAllowThreads(__tstate);
8538 if (PyErr_Occurred()) SWIG_fail;
8539 }
8540 resultobj = SWIG_From_double(static_cast< double >(result));
8541 return resultobj;
8542 fail:
8543 return NULL;
8544 }
8545
8546
8547 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8548 PyObject *resultobj = 0;
8549 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8550 wxPoint2D result;
8551 void *argp1 = 0 ;
8552 int res1 = 0 ;
8553 PyObject *swig_obj[1] ;
8554
8555 if (!args) SWIG_fail;
8556 swig_obj[0] = args;
8557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8558 if (!SWIG_IsOK(res1)) {
8559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8560 }
8561 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8562 {
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 result = (arg1)->operator -();
8565 wxPyEndAllowThreads(__tstate);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj = 0;
8577 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8578 wxPoint2D *arg2 = 0 ;
8579 wxPoint2D *result = 0 ;
8580 void *argp1 = 0 ;
8581 int res1 = 0 ;
8582 wxPoint2D temp2 ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char * kwnames[] = {
8586 (char *) "self",(char *) "pt", NULL
8587 };
8588
8589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8591 if (!SWIG_IsOK(res1)) {
8592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8593 }
8594 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8595 {
8596 arg2 = &temp2;
8597 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8598 }
8599 {
8600 PyThreadState* __tstate = wxPyBeginAllowThreads();
8601 {
8602 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8603 result = (wxPoint2D *) &_result_ref;
8604 }
8605 wxPyEndAllowThreads(__tstate);
8606 if (PyErr_Occurred()) SWIG_fail;
8607 }
8608 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8609 return resultobj;
8610 fail:
8611 return NULL;
8612 }
8613
8614
8615 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8616 PyObject *resultobj = 0;
8617 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8618 wxPoint2D *arg2 = 0 ;
8619 wxPoint2D *result = 0 ;
8620 void *argp1 = 0 ;
8621 int res1 = 0 ;
8622 wxPoint2D temp2 ;
8623 PyObject * obj0 = 0 ;
8624 PyObject * obj1 = 0 ;
8625 char * kwnames[] = {
8626 (char *) "self",(char *) "pt", NULL
8627 };
8628
8629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8631 if (!SWIG_IsOK(res1)) {
8632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8633 }
8634 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8635 {
8636 arg2 = &temp2;
8637 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8638 }
8639 {
8640 PyThreadState* __tstate = wxPyBeginAllowThreads();
8641 {
8642 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8643 result = (wxPoint2D *) &_result_ref;
8644 }
8645 wxPyEndAllowThreads(__tstate);
8646 if (PyErr_Occurred()) SWIG_fail;
8647 }
8648 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8649 return resultobj;
8650 fail:
8651 return NULL;
8652 }
8653
8654
8655 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8656 PyObject *resultobj = 0;
8657 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8658 wxPoint2D *arg2 = 0 ;
8659 wxPoint2D *result = 0 ;
8660 void *argp1 = 0 ;
8661 int res1 = 0 ;
8662 wxPoint2D temp2 ;
8663 PyObject * obj0 = 0 ;
8664 PyObject * obj1 = 0 ;
8665 char * kwnames[] = {
8666 (char *) "self",(char *) "pt", NULL
8667 };
8668
8669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8671 if (!SWIG_IsOK(res1)) {
8672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8673 }
8674 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8675 {
8676 arg2 = &temp2;
8677 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8678 }
8679 {
8680 PyThreadState* __tstate = wxPyBeginAllowThreads();
8681 {
8682 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8683 result = (wxPoint2D *) &_result_ref;
8684 }
8685 wxPyEndAllowThreads(__tstate);
8686 if (PyErr_Occurred()) SWIG_fail;
8687 }
8688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8689 return resultobj;
8690 fail:
8691 return NULL;
8692 }
8693
8694
8695 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8696 PyObject *resultobj = 0;
8697 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8698 wxPoint2D *arg2 = 0 ;
8699 wxPoint2D *result = 0 ;
8700 void *argp1 = 0 ;
8701 int res1 = 0 ;
8702 wxPoint2D temp2 ;
8703 PyObject * obj0 = 0 ;
8704 PyObject * obj1 = 0 ;
8705 char * kwnames[] = {
8706 (char *) "self",(char *) "pt", NULL
8707 };
8708
8709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8711 if (!SWIG_IsOK(res1)) {
8712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8713 }
8714 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8715 {
8716 arg2 = &temp2;
8717 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8718 }
8719 {
8720 PyThreadState* __tstate = wxPyBeginAllowThreads();
8721 {
8722 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8723 result = (wxPoint2D *) &_result_ref;
8724 }
8725 wxPyEndAllowThreads(__tstate);
8726 if (PyErr_Occurred()) SWIG_fail;
8727 }
8728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8729 return resultobj;
8730 fail:
8731 return NULL;
8732 }
8733
8734
8735 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8736 PyObject *resultobj = 0;
8737 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8738 PyObject *arg2 = (PyObject *) 0 ;
8739 bool result;
8740 void *argp1 = 0 ;
8741 int res1 = 0 ;
8742 PyObject * obj0 = 0 ;
8743 PyObject * obj1 = 0 ;
8744 char * kwnames[] = {
8745 (char *) "self",(char *) "other", NULL
8746 };
8747
8748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8750 if (!SWIG_IsOK(res1)) {
8751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8752 }
8753 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8754 arg2 = obj1;
8755 {
8756 result = (bool)wxPoint2D___eq__(arg1,arg2);
8757 if (PyErr_Occurred()) SWIG_fail;
8758 }
8759 {
8760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8761 }
8762 return resultobj;
8763 fail:
8764 return NULL;
8765 }
8766
8767
8768 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8769 PyObject *resultobj = 0;
8770 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8771 PyObject *arg2 = (PyObject *) 0 ;
8772 bool result;
8773 void *argp1 = 0 ;
8774 int res1 = 0 ;
8775 PyObject * obj0 = 0 ;
8776 PyObject * obj1 = 0 ;
8777 char * kwnames[] = {
8778 (char *) "self",(char *) "other", NULL
8779 };
8780
8781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8783 if (!SWIG_IsOK(res1)) {
8784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8785 }
8786 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8787 arg2 = obj1;
8788 {
8789 result = (bool)wxPoint2D___ne__(arg1,arg2);
8790 if (PyErr_Occurred()) SWIG_fail;
8791 }
8792 {
8793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8794 }
8795 return resultobj;
8796 fail:
8797 return NULL;
8798 }
8799
8800
8801 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8802 PyObject *resultobj = 0;
8803 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8804 double arg2 ;
8805 void *argp1 = 0 ;
8806 int res1 = 0 ;
8807 double val2 ;
8808 int ecode2 = 0 ;
8809 PyObject *swig_obj[2] ;
8810
8811 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8813 if (!SWIG_IsOK(res1)) {
8814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8815 }
8816 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8817 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8818 if (!SWIG_IsOK(ecode2)) {
8819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8820 }
8821 arg2 = static_cast< double >(val2);
8822 if (arg1) (arg1)->m_x = arg2;
8823
8824 resultobj = SWIG_Py_Void();
8825 return resultobj;
8826 fail:
8827 return NULL;
8828 }
8829
8830
8831 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8832 PyObject *resultobj = 0;
8833 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8834 double result;
8835 void *argp1 = 0 ;
8836 int res1 = 0 ;
8837 PyObject *swig_obj[1] ;
8838
8839 if (!args) SWIG_fail;
8840 swig_obj[0] = args;
8841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8842 if (!SWIG_IsOK(res1)) {
8843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8844 }
8845 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8846 result = (double) ((arg1)->m_x);
8847 resultobj = SWIG_From_double(static_cast< double >(result));
8848 return resultobj;
8849 fail:
8850 return NULL;
8851 }
8852
8853
8854 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8855 PyObject *resultobj = 0;
8856 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8857 double arg2 ;
8858 void *argp1 = 0 ;
8859 int res1 = 0 ;
8860 double val2 ;
8861 int ecode2 = 0 ;
8862 PyObject *swig_obj[2] ;
8863
8864 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8866 if (!SWIG_IsOK(res1)) {
8867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8868 }
8869 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8870 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8871 if (!SWIG_IsOK(ecode2)) {
8872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8873 }
8874 arg2 = static_cast< double >(val2);
8875 if (arg1) (arg1)->m_y = arg2;
8876
8877 resultobj = SWIG_Py_Void();
8878 return resultobj;
8879 fail:
8880 return NULL;
8881 }
8882
8883
8884 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8885 PyObject *resultobj = 0;
8886 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8887 double result;
8888 void *argp1 = 0 ;
8889 int res1 = 0 ;
8890 PyObject *swig_obj[1] ;
8891
8892 if (!args) SWIG_fail;
8893 swig_obj[0] = args;
8894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8895 if (!SWIG_IsOK(res1)) {
8896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8897 }
8898 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8899 result = (double) ((arg1)->m_y);
8900 resultobj = SWIG_From_double(static_cast< double >(result));
8901 return resultobj;
8902 fail:
8903 return NULL;
8904 }
8905
8906
8907 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj = 0;
8909 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8910 double arg2 = (double) 0 ;
8911 double arg3 = (double) 0 ;
8912 void *argp1 = 0 ;
8913 int res1 = 0 ;
8914 double val2 ;
8915 int ecode2 = 0 ;
8916 double val3 ;
8917 int ecode3 = 0 ;
8918 PyObject * obj0 = 0 ;
8919 PyObject * obj1 = 0 ;
8920 PyObject * obj2 = 0 ;
8921 char * kwnames[] = {
8922 (char *) "self",(char *) "x",(char *) "y", NULL
8923 };
8924
8925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8927 if (!SWIG_IsOK(res1)) {
8928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8929 }
8930 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8931 if (obj1) {
8932 ecode2 = SWIG_AsVal_double(obj1, &val2);
8933 if (!SWIG_IsOK(ecode2)) {
8934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8935 }
8936 arg2 = static_cast< double >(val2);
8937 }
8938 if (obj2) {
8939 ecode3 = SWIG_AsVal_double(obj2, &val3);
8940 if (!SWIG_IsOK(ecode3)) {
8941 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8942 }
8943 arg3 = static_cast< double >(val3);
8944 }
8945 {
8946 PyThreadState* __tstate = wxPyBeginAllowThreads();
8947 wxPoint2D_Set(arg1,arg2,arg3);
8948 wxPyEndAllowThreads(__tstate);
8949 if (PyErr_Occurred()) SWIG_fail;
8950 }
8951 resultobj = SWIG_Py_Void();
8952 return resultobj;
8953 fail:
8954 return NULL;
8955 }
8956
8957
8958 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8959 PyObject *resultobj = 0;
8960 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8961 PyObject *result = 0 ;
8962 void *argp1 = 0 ;
8963 int res1 = 0 ;
8964 PyObject *swig_obj[1] ;
8965
8966 if (!args) SWIG_fail;
8967 swig_obj[0] = args;
8968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8969 if (!SWIG_IsOK(res1)) {
8970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8971 }
8972 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8973 {
8974 PyThreadState* __tstate = wxPyBeginAllowThreads();
8975 result = (PyObject *)wxPoint2D_Get(arg1);
8976 wxPyEndAllowThreads(__tstate);
8977 if (PyErr_Occurred()) SWIG_fail;
8978 }
8979 resultobj = result;
8980 return resultobj;
8981 fail:
8982 return NULL;
8983 }
8984
8985
8986 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8987 PyObject *obj;
8988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8989 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8990 return SWIG_Py_Void();
8991 }
8992
8993 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8994 return SWIG_Python_InitShadowInstance(args);
8995 }
8996
8997 SWIGINTERN int DefaultPosition_set(PyObject *) {
8998 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8999 return 1;
9000 }
9001
9002
9003 SWIGINTERN PyObject *DefaultPosition_get(void) {
9004 PyObject *pyobj = 0;
9005
9006 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
9007 return pyobj;
9008 }
9009
9010
9011 SWIGINTERN int DefaultSize_set(PyObject *) {
9012 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
9013 return 1;
9014 }
9015
9016
9017 SWIGINTERN PyObject *DefaultSize_get(void) {
9018 PyObject *pyobj = 0;
9019
9020 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
9021 return pyobj;
9022 }
9023
9024
9025 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9026 PyObject *resultobj = 0;
9027 PyObject *arg1 = (PyObject *) 0 ;
9028 wxPyInputStream *result = 0 ;
9029 PyObject * obj0 = 0 ;
9030 char * kwnames[] = {
9031 (char *) "p", NULL
9032 };
9033
9034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
9035 arg1 = obj0;
9036 {
9037 PyThreadState* __tstate = wxPyBeginAllowThreads();
9038 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
9039 wxPyEndAllowThreads(__tstate);
9040 if (PyErr_Occurred()) SWIG_fail;
9041 }
9042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
9043 return resultobj;
9044 fail:
9045 return NULL;
9046 }
9047
9048
9049 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9050 PyObject *resultobj = 0;
9051 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9052 void *argp1 = 0 ;
9053 int res1 = 0 ;
9054 PyObject *swig_obj[1] ;
9055
9056 if (!args) SWIG_fail;
9057 swig_obj[0] = args;
9058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
9059 if (!SWIG_IsOK(res1)) {
9060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9061 }
9062 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9063 {
9064 PyThreadState* __tstate = wxPyBeginAllowThreads();
9065 delete arg1;
9066
9067 wxPyEndAllowThreads(__tstate);
9068 if (PyErr_Occurred()) SWIG_fail;
9069 }
9070 resultobj = SWIG_Py_Void();
9071 return resultobj;
9072 fail:
9073 return NULL;
9074 }
9075
9076
9077 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9078 PyObject *resultobj = 0;
9079 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9080 void *argp1 = 0 ;
9081 int res1 = 0 ;
9082 PyObject *swig_obj[1] ;
9083
9084 if (!args) SWIG_fail;
9085 swig_obj[0] = args;
9086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9087 if (!SWIG_IsOK(res1)) {
9088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9089 }
9090 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9091 {
9092 PyThreadState* __tstate = wxPyBeginAllowThreads();
9093 (arg1)->close();
9094 wxPyEndAllowThreads(__tstate);
9095 if (PyErr_Occurred()) SWIG_fail;
9096 }
9097 resultobj = SWIG_Py_Void();
9098 return resultobj;
9099 fail:
9100 return NULL;
9101 }
9102
9103
9104 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9105 PyObject *resultobj = 0;
9106 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9107 void *argp1 = 0 ;
9108 int res1 = 0 ;
9109 PyObject *swig_obj[1] ;
9110
9111 if (!args) SWIG_fail;
9112 swig_obj[0] = args;
9113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9114 if (!SWIG_IsOK(res1)) {
9115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9116 }
9117 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9118 {
9119 PyThreadState* __tstate = wxPyBeginAllowThreads();
9120 (arg1)->flush();
9121 wxPyEndAllowThreads(__tstate);
9122 if (PyErr_Occurred()) SWIG_fail;
9123 }
9124 resultobj = SWIG_Py_Void();
9125 return resultobj;
9126 fail:
9127 return NULL;
9128 }
9129
9130
9131 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9132 PyObject *resultobj = 0;
9133 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9134 bool result;
9135 void *argp1 = 0 ;
9136 int res1 = 0 ;
9137 PyObject *swig_obj[1] ;
9138
9139 if (!args) SWIG_fail;
9140 swig_obj[0] = args;
9141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9142 if (!SWIG_IsOK(res1)) {
9143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9144 }
9145 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9146 {
9147 PyThreadState* __tstate = wxPyBeginAllowThreads();
9148 result = (bool)(arg1)->eof();
9149 wxPyEndAllowThreads(__tstate);
9150 if (PyErr_Occurred()) SWIG_fail;
9151 }
9152 {
9153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9154 }
9155 return resultobj;
9156 fail:
9157 return NULL;
9158 }
9159
9160
9161 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9162 PyObject *resultobj = 0;
9163 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9164 int arg2 = (int) -1 ;
9165 PyObject *result = 0 ;
9166 void *argp1 = 0 ;
9167 int res1 = 0 ;
9168 int val2 ;
9169 int ecode2 = 0 ;
9170 PyObject * obj0 = 0 ;
9171 PyObject * obj1 = 0 ;
9172 char * kwnames[] = {
9173 (char *) "self",(char *) "size", NULL
9174 };
9175
9176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9178 if (!SWIG_IsOK(res1)) {
9179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9180 }
9181 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9182 if (obj1) {
9183 ecode2 = SWIG_AsVal_int(obj1, &val2);
9184 if (!SWIG_IsOK(ecode2)) {
9185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9186 }
9187 arg2 = static_cast< int >(val2);
9188 }
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 result = (PyObject *)(arg1)->read(arg2);
9192 wxPyEndAllowThreads(__tstate);
9193 if (PyErr_Occurred()) SWIG_fail;
9194 }
9195 resultobj = result;
9196 return resultobj;
9197 fail:
9198 return NULL;
9199 }
9200
9201
9202 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9203 PyObject *resultobj = 0;
9204 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9205 int arg2 = (int) -1 ;
9206 PyObject *result = 0 ;
9207 void *argp1 = 0 ;
9208 int res1 = 0 ;
9209 int val2 ;
9210 int ecode2 = 0 ;
9211 PyObject * obj0 = 0 ;
9212 PyObject * obj1 = 0 ;
9213 char * kwnames[] = {
9214 (char *) "self",(char *) "size", NULL
9215 };
9216
9217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9219 if (!SWIG_IsOK(res1)) {
9220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9221 }
9222 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9223 if (obj1) {
9224 ecode2 = SWIG_AsVal_int(obj1, &val2);
9225 if (!SWIG_IsOK(ecode2)) {
9226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9227 }
9228 arg2 = static_cast< int >(val2);
9229 }
9230 {
9231 PyThreadState* __tstate = wxPyBeginAllowThreads();
9232 result = (PyObject *)(arg1)->readline(arg2);
9233 wxPyEndAllowThreads(__tstate);
9234 if (PyErr_Occurred()) SWIG_fail;
9235 }
9236 resultobj = result;
9237 return resultobj;
9238 fail:
9239 return NULL;
9240 }
9241
9242
9243 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9244 PyObject *resultobj = 0;
9245 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9246 int arg2 = (int) -1 ;
9247 PyObject *result = 0 ;
9248 void *argp1 = 0 ;
9249 int res1 = 0 ;
9250 int val2 ;
9251 int ecode2 = 0 ;
9252 PyObject * obj0 = 0 ;
9253 PyObject * obj1 = 0 ;
9254 char * kwnames[] = {
9255 (char *) "self",(char *) "sizehint", NULL
9256 };
9257
9258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9260 if (!SWIG_IsOK(res1)) {
9261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9262 }
9263 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9264 if (obj1) {
9265 ecode2 = SWIG_AsVal_int(obj1, &val2);
9266 if (!SWIG_IsOK(ecode2)) {
9267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9268 }
9269 arg2 = static_cast< int >(val2);
9270 }
9271 {
9272 PyThreadState* __tstate = wxPyBeginAllowThreads();
9273 result = (PyObject *)(arg1)->readlines(arg2);
9274 wxPyEndAllowThreads(__tstate);
9275 if (PyErr_Occurred()) SWIG_fail;
9276 }
9277 resultobj = result;
9278 return resultobj;
9279 fail:
9280 return NULL;
9281 }
9282
9283
9284 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9285 PyObject *resultobj = 0;
9286 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9287 int arg2 ;
9288 int arg3 = (int) 0 ;
9289 void *argp1 = 0 ;
9290 int res1 = 0 ;
9291 int val2 ;
9292 int ecode2 = 0 ;
9293 int val3 ;
9294 int ecode3 = 0 ;
9295 PyObject * obj0 = 0 ;
9296 PyObject * obj1 = 0 ;
9297 PyObject * obj2 = 0 ;
9298 char * kwnames[] = {
9299 (char *) "self",(char *) "offset",(char *) "whence", NULL
9300 };
9301
9302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9304 if (!SWIG_IsOK(res1)) {
9305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9306 }
9307 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9308 ecode2 = SWIG_AsVal_int(obj1, &val2);
9309 if (!SWIG_IsOK(ecode2)) {
9310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9311 }
9312 arg2 = static_cast< int >(val2);
9313 if (obj2) {
9314 ecode3 = SWIG_AsVal_int(obj2, &val3);
9315 if (!SWIG_IsOK(ecode3)) {
9316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9317 }
9318 arg3 = static_cast< int >(val3);
9319 }
9320 {
9321 PyThreadState* __tstate = wxPyBeginAllowThreads();
9322 (arg1)->seek(arg2,arg3);
9323 wxPyEndAllowThreads(__tstate);
9324 if (PyErr_Occurred()) SWIG_fail;
9325 }
9326 resultobj = SWIG_Py_Void();
9327 return resultobj;
9328 fail:
9329 return NULL;
9330 }
9331
9332
9333 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9334 PyObject *resultobj = 0;
9335 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9336 int result;
9337 void *argp1 = 0 ;
9338 int res1 = 0 ;
9339 PyObject *swig_obj[1] ;
9340
9341 if (!args) SWIG_fail;
9342 swig_obj[0] = args;
9343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9344 if (!SWIG_IsOK(res1)) {
9345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9346 }
9347 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9348 {
9349 PyThreadState* __tstate = wxPyBeginAllowThreads();
9350 result = (int)(arg1)->tell();
9351 wxPyEndAllowThreads(__tstate);
9352 if (PyErr_Occurred()) SWIG_fail;
9353 }
9354 resultobj = SWIG_From_int(static_cast< int >(result));
9355 return resultobj;
9356 fail:
9357 return NULL;
9358 }
9359
9360
9361 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9362 PyObject *resultobj = 0;
9363 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9364 char result;
9365 void *argp1 = 0 ;
9366 int res1 = 0 ;
9367 PyObject *swig_obj[1] ;
9368
9369 if (!args) SWIG_fail;
9370 swig_obj[0] = args;
9371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9372 if (!SWIG_IsOK(res1)) {
9373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9374 }
9375 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9376 {
9377 PyThreadState* __tstate = wxPyBeginAllowThreads();
9378 result = (char)(arg1)->Peek();
9379 wxPyEndAllowThreads(__tstate);
9380 if (PyErr_Occurred()) SWIG_fail;
9381 }
9382 resultobj = SWIG_From_char(static_cast< char >(result));
9383 return resultobj;
9384 fail:
9385 return NULL;
9386 }
9387
9388
9389 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9390 PyObject *resultobj = 0;
9391 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9392 char result;
9393 void *argp1 = 0 ;
9394 int res1 = 0 ;
9395 PyObject *swig_obj[1] ;
9396
9397 if (!args) SWIG_fail;
9398 swig_obj[0] = args;
9399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9400 if (!SWIG_IsOK(res1)) {
9401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9402 }
9403 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9404 {
9405 PyThreadState* __tstate = wxPyBeginAllowThreads();
9406 result = (char)(arg1)->GetC();
9407 wxPyEndAllowThreads(__tstate);
9408 if (PyErr_Occurred()) SWIG_fail;
9409 }
9410 resultobj = SWIG_From_char(static_cast< char >(result));
9411 return resultobj;
9412 fail:
9413 return NULL;
9414 }
9415
9416
9417 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9418 PyObject *resultobj = 0;
9419 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9420 size_t result;
9421 void *argp1 = 0 ;
9422 int res1 = 0 ;
9423 PyObject *swig_obj[1] ;
9424
9425 if (!args) SWIG_fail;
9426 swig_obj[0] = args;
9427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9428 if (!SWIG_IsOK(res1)) {
9429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9430 }
9431 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9432 {
9433 PyThreadState* __tstate = wxPyBeginAllowThreads();
9434 result = (size_t)(arg1)->LastRead();
9435 wxPyEndAllowThreads(__tstate);
9436 if (PyErr_Occurred()) SWIG_fail;
9437 }
9438 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9439 return resultobj;
9440 fail:
9441 return NULL;
9442 }
9443
9444
9445 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9446 PyObject *resultobj = 0;
9447 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9448 bool result;
9449 void *argp1 = 0 ;
9450 int res1 = 0 ;
9451 PyObject *swig_obj[1] ;
9452
9453 if (!args) SWIG_fail;
9454 swig_obj[0] = args;
9455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9456 if (!SWIG_IsOK(res1)) {
9457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9458 }
9459 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9460 {
9461 PyThreadState* __tstate = wxPyBeginAllowThreads();
9462 result = (bool)(arg1)->CanRead();
9463 wxPyEndAllowThreads(__tstate);
9464 if (PyErr_Occurred()) SWIG_fail;
9465 }
9466 {
9467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9468 }
9469 return resultobj;
9470 fail:
9471 return NULL;
9472 }
9473
9474
9475 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9476 PyObject *resultobj = 0;
9477 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9478 bool result;
9479 void *argp1 = 0 ;
9480 int res1 = 0 ;
9481 PyObject *swig_obj[1] ;
9482
9483 if (!args) SWIG_fail;
9484 swig_obj[0] = args;
9485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9486 if (!SWIG_IsOK(res1)) {
9487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9488 }
9489 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9490 {
9491 PyThreadState* __tstate = wxPyBeginAllowThreads();
9492 result = (bool)(arg1)->Eof();
9493 wxPyEndAllowThreads(__tstate);
9494 if (PyErr_Occurred()) SWIG_fail;
9495 }
9496 {
9497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9498 }
9499 return resultobj;
9500 fail:
9501 return NULL;
9502 }
9503
9504
9505 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9506 PyObject *resultobj = 0;
9507 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9508 char arg2 ;
9509 bool result;
9510 void *argp1 = 0 ;
9511 int res1 = 0 ;
9512 char val2 ;
9513 int ecode2 = 0 ;
9514 PyObject * obj0 = 0 ;
9515 PyObject * obj1 = 0 ;
9516 char * kwnames[] = {
9517 (char *) "self",(char *) "c", NULL
9518 };
9519
9520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9522 if (!SWIG_IsOK(res1)) {
9523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9524 }
9525 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9526 ecode2 = SWIG_AsVal_char(obj1, &val2);
9527 if (!SWIG_IsOK(ecode2)) {
9528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9529 }
9530 arg2 = static_cast< char >(val2);
9531 {
9532 PyThreadState* __tstate = wxPyBeginAllowThreads();
9533 result = (bool)(arg1)->Ungetch(arg2);
9534 wxPyEndAllowThreads(__tstate);
9535 if (PyErr_Occurred()) SWIG_fail;
9536 }
9537 {
9538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9539 }
9540 return resultobj;
9541 fail:
9542 return NULL;
9543 }
9544
9545
9546 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9547 PyObject *resultobj = 0;
9548 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9549 long arg2 ;
9550 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9551 long result;
9552 void *argp1 = 0 ;
9553 int res1 = 0 ;
9554 long val2 ;
9555 int ecode2 = 0 ;
9556 int val3 ;
9557 int ecode3 = 0 ;
9558 PyObject * obj0 = 0 ;
9559 PyObject * obj1 = 0 ;
9560 PyObject * obj2 = 0 ;
9561 char * kwnames[] = {
9562 (char *) "self",(char *) "pos",(char *) "mode", NULL
9563 };
9564
9565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9567 if (!SWIG_IsOK(res1)) {
9568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9569 }
9570 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9571 ecode2 = SWIG_AsVal_long(obj1, &val2);
9572 if (!SWIG_IsOK(ecode2)) {
9573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9574 }
9575 arg2 = static_cast< long >(val2);
9576 if (obj2) {
9577 ecode3 = SWIG_AsVal_int(obj2, &val3);
9578 if (!SWIG_IsOK(ecode3)) {
9579 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9580 }
9581 arg3 = static_cast< wxSeekMode >(val3);
9582 }
9583 {
9584 PyThreadState* __tstate = wxPyBeginAllowThreads();
9585 result = (long)(arg1)->SeekI(arg2,arg3);
9586 wxPyEndAllowThreads(__tstate);
9587 if (PyErr_Occurred()) SWIG_fail;
9588 }
9589 resultobj = SWIG_From_long(static_cast< long >(result));
9590 return resultobj;
9591 fail:
9592 return NULL;
9593 }
9594
9595
9596 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9597 PyObject *resultobj = 0;
9598 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9599 long result;
9600 void *argp1 = 0 ;
9601 int res1 = 0 ;
9602 PyObject *swig_obj[1] ;
9603
9604 if (!args) SWIG_fail;
9605 swig_obj[0] = args;
9606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9607 if (!SWIG_IsOK(res1)) {
9608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9609 }
9610 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9611 {
9612 PyThreadState* __tstate = wxPyBeginAllowThreads();
9613 result = (long)(arg1)->TellI();
9614 wxPyEndAllowThreads(__tstate);
9615 if (PyErr_Occurred()) SWIG_fail;
9616 }
9617 resultobj = SWIG_From_long(static_cast< long >(result));
9618 return resultobj;
9619 fail:
9620 return NULL;
9621 }
9622
9623
9624 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9625 PyObject *obj;
9626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9627 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9628 return SWIG_Py_Void();
9629 }
9630
9631 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9632 return SWIG_Python_InitShadowInstance(args);
9633 }
9634
9635 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9636 PyObject *resultobj = 0;
9637 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9638 PyObject *arg2 = (PyObject *) 0 ;
9639 void *argp1 = 0 ;
9640 int res1 = 0 ;
9641 PyObject * obj0 = 0 ;
9642 PyObject * obj1 = 0 ;
9643 char * kwnames[] = {
9644 (char *) "self",(char *) "obj", NULL
9645 };
9646
9647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9649 if (!SWIG_IsOK(res1)) {
9650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9651 }
9652 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9653 arg2 = obj1;
9654 {
9655 PyThreadState* __tstate = wxPyBeginAllowThreads();
9656 wxOutputStream_write(arg1,arg2);
9657 wxPyEndAllowThreads(__tstate);
9658 if (PyErr_Occurred()) SWIG_fail;
9659 }
9660 resultobj = SWIG_Py_Void();
9661 return resultobj;
9662 fail:
9663 return NULL;
9664 }
9665
9666
9667 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9668 PyObject *resultobj = 0;
9669 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9670 size_t result;
9671 void *argp1 = 0 ;
9672 int res1 = 0 ;
9673 PyObject *swig_obj[1] ;
9674
9675 if (!args) SWIG_fail;
9676 swig_obj[0] = args;
9677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9678 if (!SWIG_IsOK(res1)) {
9679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9680 }
9681 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9682 {
9683 PyThreadState* __tstate = wxPyBeginAllowThreads();
9684 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9685 wxPyEndAllowThreads(__tstate);
9686 if (PyErr_Occurred()) SWIG_fail;
9687 }
9688 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9689 return resultobj;
9690 fail:
9691 return NULL;
9692 }
9693
9694
9695 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9696 PyObject *obj;
9697 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9698 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9699 return SWIG_Py_Void();
9700 }
9701
9702 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9703 PyObject *resultobj = 0;
9704 wxInputStream *arg1 = (wxInputStream *) 0 ;
9705 wxString *arg2 = 0 ;
9706 wxString *arg3 = 0 ;
9707 wxString *arg4 = 0 ;
9708 wxDateTime arg5 ;
9709 wxFSFile *result = 0 ;
9710 wxPyInputStream *temp1 ;
9711 bool temp2 = false ;
9712 bool temp3 = false ;
9713 bool temp4 = false ;
9714 void *argp5 ;
9715 int res5 = 0 ;
9716 PyObject * obj0 = 0 ;
9717 PyObject * obj1 = 0 ;
9718 PyObject * obj2 = 0 ;
9719 PyObject * obj3 = 0 ;
9720 PyObject * obj4 = 0 ;
9721 char * kwnames[] = {
9722 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9723 };
9724
9725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9726 {
9727 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9728 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9729 } else {
9730 PyErr_Clear(); // clear the failure of the wxPyConvert above
9731 arg1 = wxPyCBInputStream_create(obj0, true);
9732 if (arg1 == NULL) {
9733 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9734 SWIG_fail;
9735 }
9736 }
9737 }
9738 {
9739 arg2 = wxString_in_helper(obj1);
9740 if (arg2 == NULL) SWIG_fail;
9741 temp2 = true;
9742 }
9743 {
9744 arg3 = wxString_in_helper(obj2);
9745 if (arg3 == NULL) SWIG_fail;
9746 temp3 = true;
9747 }
9748 {
9749 arg4 = wxString_in_helper(obj3);
9750 if (arg4 == NULL) SWIG_fail;
9751 temp4 = true;
9752 }
9753 {
9754 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9755 if (!SWIG_IsOK(res5)) {
9756 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9757 }
9758 if (!argp5) {
9759 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9760 } else {
9761 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9762 arg5 = *temp;
9763 if (SWIG_IsNewObj(res5)) delete temp;
9764 }
9765 }
9766 {
9767 PyThreadState* __tstate = wxPyBeginAllowThreads();
9768 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9769 wxPyEndAllowThreads(__tstate);
9770 if (PyErr_Occurred()) SWIG_fail;
9771 }
9772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9773 {
9774 if (temp2)
9775 delete arg2;
9776 }
9777 {
9778 if (temp3)
9779 delete arg3;
9780 }
9781 {
9782 if (temp4)
9783 delete arg4;
9784 }
9785 return resultobj;
9786 fail:
9787 {
9788 if (temp2)
9789 delete arg2;
9790 }
9791 {
9792 if (temp3)
9793 delete arg3;
9794 }
9795 {
9796 if (temp4)
9797 delete arg4;
9798 }
9799 return NULL;
9800 }
9801
9802
9803 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9804 PyObject *resultobj = 0;
9805 wxFSFile *arg1 = (wxFSFile *) 0 ;
9806 void *argp1 = 0 ;
9807 int res1 = 0 ;
9808 PyObject *swig_obj[1] ;
9809
9810 if (!args) SWIG_fail;
9811 swig_obj[0] = args;
9812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9813 if (!SWIG_IsOK(res1)) {
9814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9815 }
9816 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9817 {
9818 PyThreadState* __tstate = wxPyBeginAllowThreads();
9819 delete arg1;
9820
9821 wxPyEndAllowThreads(__tstate);
9822 if (PyErr_Occurred()) SWIG_fail;
9823 }
9824 resultobj = SWIG_Py_Void();
9825 return resultobj;
9826 fail:
9827 return NULL;
9828 }
9829
9830
9831 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9832 PyObject *resultobj = 0;
9833 wxFSFile *arg1 = (wxFSFile *) 0 ;
9834 wxInputStream *result = 0 ;
9835 void *argp1 = 0 ;
9836 int res1 = 0 ;
9837 PyObject *swig_obj[1] ;
9838
9839 if (!args) SWIG_fail;
9840 swig_obj[0] = args;
9841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9842 if (!SWIG_IsOK(res1)) {
9843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9844 }
9845 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9846 {
9847 PyThreadState* __tstate = wxPyBeginAllowThreads();
9848 result = (wxInputStream *)(arg1)->GetStream();
9849 wxPyEndAllowThreads(__tstate);
9850 if (PyErr_Occurred()) SWIG_fail;
9851 }
9852 {
9853 wxPyInputStream * _ptr = NULL;
9854
9855 if (result) {
9856 _ptr = new wxPyInputStream(result);
9857 }
9858 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9859 }
9860 return resultobj;
9861 fail:
9862 return NULL;
9863 }
9864
9865
9866 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9867 PyObject *resultobj = 0;
9868 wxFSFile *arg1 = (wxFSFile *) 0 ;
9869 void *argp1 = 0 ;
9870 int res1 = 0 ;
9871 PyObject *swig_obj[1] ;
9872
9873 if (!args) SWIG_fail;
9874 swig_obj[0] = args;
9875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9876 if (!SWIG_IsOK(res1)) {
9877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9878 }
9879 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 (arg1)->DetachStream();
9883 wxPyEndAllowThreads(__tstate);
9884 if (PyErr_Occurred()) SWIG_fail;
9885 }
9886 resultobj = SWIG_Py_Void();
9887 return resultobj;
9888 fail:
9889 return NULL;
9890 }
9891
9892
9893 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9894 PyObject *resultobj = 0;
9895 wxFSFile *arg1 = (wxFSFile *) 0 ;
9896 wxString *result = 0 ;
9897 void *argp1 = 0 ;
9898 int res1 = 0 ;
9899 PyObject *swig_obj[1] ;
9900
9901 if (!args) SWIG_fail;
9902 swig_obj[0] = args;
9903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9904 if (!SWIG_IsOK(res1)) {
9905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9906 }
9907 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9908 {
9909 PyThreadState* __tstate = wxPyBeginAllowThreads();
9910 {
9911 wxString const &_result_ref = (arg1)->GetMimeType();
9912 result = (wxString *) &_result_ref;
9913 }
9914 wxPyEndAllowThreads(__tstate);
9915 if (PyErr_Occurred()) SWIG_fail;
9916 }
9917 {
9918 #if wxUSE_UNICODE
9919 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9920 #else
9921 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9922 #endif
9923 }
9924 return resultobj;
9925 fail:
9926 return NULL;
9927 }
9928
9929
9930 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9931 PyObject *resultobj = 0;
9932 wxFSFile *arg1 = (wxFSFile *) 0 ;
9933 wxString *result = 0 ;
9934 void *argp1 = 0 ;
9935 int res1 = 0 ;
9936 PyObject *swig_obj[1] ;
9937
9938 if (!args) SWIG_fail;
9939 swig_obj[0] = args;
9940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9941 if (!SWIG_IsOK(res1)) {
9942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9943 }
9944 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9945 {
9946 PyThreadState* __tstate = wxPyBeginAllowThreads();
9947 {
9948 wxString const &_result_ref = (arg1)->GetLocation();
9949 result = (wxString *) &_result_ref;
9950 }
9951 wxPyEndAllowThreads(__tstate);
9952 if (PyErr_Occurred()) SWIG_fail;
9953 }
9954 {
9955 #if wxUSE_UNICODE
9956 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9957 #else
9958 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9959 #endif
9960 }
9961 return resultobj;
9962 fail:
9963 return NULL;
9964 }
9965
9966
9967 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9968 PyObject *resultobj = 0;
9969 wxFSFile *arg1 = (wxFSFile *) 0 ;
9970 wxString *result = 0 ;
9971 void *argp1 = 0 ;
9972 int res1 = 0 ;
9973 PyObject *swig_obj[1] ;
9974
9975 if (!args) SWIG_fail;
9976 swig_obj[0] = args;
9977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9978 if (!SWIG_IsOK(res1)) {
9979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9980 }
9981 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9982 {
9983 PyThreadState* __tstate = wxPyBeginAllowThreads();
9984 {
9985 wxString const &_result_ref = (arg1)->GetAnchor();
9986 result = (wxString *) &_result_ref;
9987 }
9988 wxPyEndAllowThreads(__tstate);
9989 if (PyErr_Occurred()) SWIG_fail;
9990 }
9991 {
9992 #if wxUSE_UNICODE
9993 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9994 #else
9995 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9996 #endif
9997 }
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10005 PyObject *resultobj = 0;
10006 wxFSFile *arg1 = (wxFSFile *) 0 ;
10007 wxDateTime result;
10008 void *argp1 = 0 ;
10009 int res1 = 0 ;
10010 PyObject *swig_obj[1] ;
10011
10012 if (!args) SWIG_fail;
10013 swig_obj[0] = args;
10014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
10015 if (!SWIG_IsOK(res1)) {
10016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
10017 }
10018 arg1 = reinterpret_cast< wxFSFile * >(argp1);
10019 {
10020 PyThreadState* __tstate = wxPyBeginAllowThreads();
10021 result = (arg1)->GetModificationTime();
10022 wxPyEndAllowThreads(__tstate);
10023 if (PyErr_Occurred()) SWIG_fail;
10024 }
10025 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
10026 return resultobj;
10027 fail:
10028 return NULL;
10029 }
10030
10031
10032 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10033 PyObject *obj;
10034 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10035 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
10036 return SWIG_Py_Void();
10037 }
10038
10039 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10040 return SWIG_Python_InitShadowInstance(args);
10041 }
10042
10043 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10044 PyObject *resultobj = 0;
10045 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10046 void *argp1 = 0 ;
10047 int res1 = 0 ;
10048 PyObject *swig_obj[1] ;
10049
10050 if (!args) SWIG_fail;
10051 swig_obj[0] = args;
10052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10053 if (!SWIG_IsOK(res1)) {
10054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10055 }
10056 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10057 {
10058 PyThreadState* __tstate = wxPyBeginAllowThreads();
10059 delete arg1;
10060
10061 wxPyEndAllowThreads(__tstate);
10062 if (PyErr_Occurred()) SWIG_fail;
10063 }
10064 resultobj = SWIG_Py_Void();
10065 return resultobj;
10066 fail:
10067 return NULL;
10068 }
10069
10070
10071 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10072 PyObject *obj;
10073 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10074 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
10075 return SWIG_Py_Void();
10076 }
10077
10078 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10079 PyObject *resultobj = 0;
10080 wxPyFileSystemHandler *result = 0 ;
10081
10082 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
10083 {
10084 PyThreadState* __tstate = wxPyBeginAllowThreads();
10085 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
10086 wxPyEndAllowThreads(__tstate);
10087 if (PyErr_Occurred()) SWIG_fail;
10088 }
10089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10090 return resultobj;
10091 fail:
10092 return NULL;
10093 }
10094
10095
10096 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj = 0;
10098 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10099 PyObject *arg2 = (PyObject *) 0 ;
10100 PyObject *arg3 = (PyObject *) 0 ;
10101 void *argp1 = 0 ;
10102 int res1 = 0 ;
10103 PyObject * obj0 = 0 ;
10104 PyObject * obj1 = 0 ;
10105 PyObject * obj2 = 0 ;
10106 char * kwnames[] = {
10107 (char *) "self",(char *) "self",(char *) "_class", NULL
10108 };
10109
10110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10112 if (!SWIG_IsOK(res1)) {
10113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10114 }
10115 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10116 arg2 = obj1;
10117 arg3 = obj2;
10118 {
10119 PyThreadState* __tstate = wxPyBeginAllowThreads();
10120 (arg1)->_setCallbackInfo(arg2,arg3);
10121 wxPyEndAllowThreads(__tstate);
10122 if (PyErr_Occurred()) SWIG_fail;
10123 }
10124 resultobj = SWIG_Py_Void();
10125 return resultobj;
10126 fail:
10127 return NULL;
10128 }
10129
10130
10131 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10132 PyObject *resultobj = 0;
10133 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10134 wxString *arg2 = 0 ;
10135 bool result;
10136 void *argp1 = 0 ;
10137 int res1 = 0 ;
10138 bool temp2 = false ;
10139 PyObject * obj0 = 0 ;
10140 PyObject * obj1 = 0 ;
10141 char * kwnames[] = {
10142 (char *) "self",(char *) "location", NULL
10143 };
10144
10145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10147 if (!SWIG_IsOK(res1)) {
10148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10149 }
10150 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10151 {
10152 arg2 = wxString_in_helper(obj1);
10153 if (arg2 == NULL) SWIG_fail;
10154 temp2 = true;
10155 }
10156 {
10157 PyThreadState* __tstate = wxPyBeginAllowThreads();
10158 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10159 wxPyEndAllowThreads(__tstate);
10160 if (PyErr_Occurred()) SWIG_fail;
10161 }
10162 {
10163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10164 }
10165 {
10166 if (temp2)
10167 delete arg2;
10168 }
10169 return resultobj;
10170 fail:
10171 {
10172 if (temp2)
10173 delete arg2;
10174 }
10175 return NULL;
10176 }
10177
10178
10179 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10180 PyObject *resultobj = 0;
10181 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10182 wxFileSystem *arg2 = 0 ;
10183 wxString *arg3 = 0 ;
10184 wxFSFile *result = 0 ;
10185 void *argp1 = 0 ;
10186 int res1 = 0 ;
10187 void *argp2 = 0 ;
10188 int res2 = 0 ;
10189 bool temp3 = false ;
10190 PyObject * obj0 = 0 ;
10191 PyObject * obj1 = 0 ;
10192 PyObject * obj2 = 0 ;
10193 char * kwnames[] = {
10194 (char *) "self",(char *) "fs",(char *) "location", NULL
10195 };
10196
10197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10199 if (!SWIG_IsOK(res1)) {
10200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10201 }
10202 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10203 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10204 if (!SWIG_IsOK(res2)) {
10205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10206 }
10207 if (!argp2) {
10208 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10209 }
10210 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10211 {
10212 arg3 = wxString_in_helper(obj2);
10213 if (arg3 == NULL) SWIG_fail;
10214 temp3 = true;
10215 }
10216 {
10217 PyThreadState* __tstate = wxPyBeginAllowThreads();
10218 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10219 wxPyEndAllowThreads(__tstate);
10220 if (PyErr_Occurred()) SWIG_fail;
10221 }
10222 {
10223 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10224 }
10225 {
10226 if (temp3)
10227 delete arg3;
10228 }
10229 return resultobj;
10230 fail:
10231 {
10232 if (temp3)
10233 delete arg3;
10234 }
10235 return NULL;
10236 }
10237
10238
10239 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10240 PyObject *resultobj = 0;
10241 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10242 wxString *arg2 = 0 ;
10243 int arg3 = (int) 0 ;
10244 wxString result;
10245 void *argp1 = 0 ;
10246 int res1 = 0 ;
10247 bool temp2 = false ;
10248 int val3 ;
10249 int ecode3 = 0 ;
10250 PyObject * obj0 = 0 ;
10251 PyObject * obj1 = 0 ;
10252 PyObject * obj2 = 0 ;
10253 char * kwnames[] = {
10254 (char *) "self",(char *) "spec",(char *) "flags", NULL
10255 };
10256
10257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10259 if (!SWIG_IsOK(res1)) {
10260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10261 }
10262 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10263 {
10264 arg2 = wxString_in_helper(obj1);
10265 if (arg2 == NULL) SWIG_fail;
10266 temp2 = true;
10267 }
10268 if (obj2) {
10269 ecode3 = SWIG_AsVal_int(obj2, &val3);
10270 if (!SWIG_IsOK(ecode3)) {
10271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10272 }
10273 arg3 = static_cast< int >(val3);
10274 }
10275 {
10276 PyThreadState* __tstate = wxPyBeginAllowThreads();
10277 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10278 wxPyEndAllowThreads(__tstate);
10279 if (PyErr_Occurred()) SWIG_fail;
10280 }
10281 {
10282 #if wxUSE_UNICODE
10283 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10284 #else
10285 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10286 #endif
10287 }
10288 {
10289 if (temp2)
10290 delete arg2;
10291 }
10292 return resultobj;
10293 fail:
10294 {
10295 if (temp2)
10296 delete arg2;
10297 }
10298 return NULL;
10299 }
10300
10301
10302 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10303 PyObject *resultobj = 0;
10304 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10305 wxString result;
10306 void *argp1 = 0 ;
10307 int res1 = 0 ;
10308 PyObject *swig_obj[1] ;
10309
10310 if (!args) SWIG_fail;
10311 swig_obj[0] = args;
10312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10313 if (!SWIG_IsOK(res1)) {
10314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10315 }
10316 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10317 {
10318 PyThreadState* __tstate = wxPyBeginAllowThreads();
10319 result = (arg1)->FindNext();
10320 wxPyEndAllowThreads(__tstate);
10321 if (PyErr_Occurred()) SWIG_fail;
10322 }
10323 {
10324 #if wxUSE_UNICODE
10325 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10326 #else
10327 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10328 #endif
10329 }
10330 return resultobj;
10331 fail:
10332 return NULL;
10333 }
10334
10335
10336 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10337 PyObject *resultobj = 0;
10338 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10339 wxString *arg2 = 0 ;
10340 wxString result;
10341 void *argp1 = 0 ;
10342 int res1 = 0 ;
10343 bool temp2 = false ;
10344 PyObject * obj0 = 0 ;
10345 PyObject * obj1 = 0 ;
10346 char * kwnames[] = {
10347 (char *) "self",(char *) "location", NULL
10348 };
10349
10350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10352 if (!SWIG_IsOK(res1)) {
10353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10354 }
10355 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10356 {
10357 arg2 = wxString_in_helper(obj1);
10358 if (arg2 == NULL) SWIG_fail;
10359 temp2 = true;
10360 }
10361 {
10362 PyThreadState* __tstate = wxPyBeginAllowThreads();
10363 result = (arg1)->GetProtocol((wxString const &)*arg2);
10364 wxPyEndAllowThreads(__tstate);
10365 if (PyErr_Occurred()) SWIG_fail;
10366 }
10367 {
10368 #if wxUSE_UNICODE
10369 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10370 #else
10371 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10372 #endif
10373 }
10374 {
10375 if (temp2)
10376 delete arg2;
10377 }
10378 return resultobj;
10379 fail:
10380 {
10381 if (temp2)
10382 delete arg2;
10383 }
10384 return NULL;
10385 }
10386
10387
10388 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10389 PyObject *resultobj = 0;
10390 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10391 wxString *arg2 = 0 ;
10392 wxString result;
10393 void *argp1 = 0 ;
10394 int res1 = 0 ;
10395 bool temp2 = false ;
10396 PyObject * obj0 = 0 ;
10397 PyObject * obj1 = 0 ;
10398 char * kwnames[] = {
10399 (char *) "self",(char *) "location", NULL
10400 };
10401
10402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10404 if (!SWIG_IsOK(res1)) {
10405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10406 }
10407 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10408 {
10409 arg2 = wxString_in_helper(obj1);
10410 if (arg2 == NULL) SWIG_fail;
10411 temp2 = true;
10412 }
10413 {
10414 PyThreadState* __tstate = wxPyBeginAllowThreads();
10415 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10416 wxPyEndAllowThreads(__tstate);
10417 if (PyErr_Occurred()) SWIG_fail;
10418 }
10419 {
10420 #if wxUSE_UNICODE
10421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10422 #else
10423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10424 #endif
10425 }
10426 {
10427 if (temp2)
10428 delete arg2;
10429 }
10430 return resultobj;
10431 fail:
10432 {
10433 if (temp2)
10434 delete arg2;
10435 }
10436 return NULL;
10437 }
10438
10439
10440 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10441 PyObject *resultobj = 0;
10442 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10443 wxString *arg2 = 0 ;
10444 wxString result;
10445 void *argp1 = 0 ;
10446 int res1 = 0 ;
10447 bool temp2 = false ;
10448 PyObject * obj0 = 0 ;
10449 PyObject * obj1 = 0 ;
10450 char * kwnames[] = {
10451 (char *) "self",(char *) "location", NULL
10452 };
10453
10454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10456 if (!SWIG_IsOK(res1)) {
10457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10458 }
10459 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10460 {
10461 arg2 = wxString_in_helper(obj1);
10462 if (arg2 == NULL) SWIG_fail;
10463 temp2 = true;
10464 }
10465 {
10466 PyThreadState* __tstate = wxPyBeginAllowThreads();
10467 result = (arg1)->GetAnchor((wxString const &)*arg2);
10468 wxPyEndAllowThreads(__tstate);
10469 if (PyErr_Occurred()) SWIG_fail;
10470 }
10471 {
10472 #if wxUSE_UNICODE
10473 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10474 #else
10475 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10476 #endif
10477 }
10478 {
10479 if (temp2)
10480 delete arg2;
10481 }
10482 return resultobj;
10483 fail:
10484 {
10485 if (temp2)
10486 delete arg2;
10487 }
10488 return NULL;
10489 }
10490
10491
10492 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10493 PyObject *resultobj = 0;
10494 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10495 wxString *arg2 = 0 ;
10496 wxString result;
10497 void *argp1 = 0 ;
10498 int res1 = 0 ;
10499 bool temp2 = false ;
10500 PyObject * obj0 = 0 ;
10501 PyObject * obj1 = 0 ;
10502 char * kwnames[] = {
10503 (char *) "self",(char *) "location", NULL
10504 };
10505
10506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10508 if (!SWIG_IsOK(res1)) {
10509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10510 }
10511 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10512 {
10513 arg2 = wxString_in_helper(obj1);
10514 if (arg2 == NULL) SWIG_fail;
10515 temp2 = true;
10516 }
10517 {
10518 PyThreadState* __tstate = wxPyBeginAllowThreads();
10519 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10520 wxPyEndAllowThreads(__tstate);
10521 if (PyErr_Occurred()) SWIG_fail;
10522 }
10523 {
10524 #if wxUSE_UNICODE
10525 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10526 #else
10527 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10528 #endif
10529 }
10530 {
10531 if (temp2)
10532 delete arg2;
10533 }
10534 return resultobj;
10535 fail:
10536 {
10537 if (temp2)
10538 delete arg2;
10539 }
10540 return NULL;
10541 }
10542
10543
10544 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10545 PyObject *resultobj = 0;
10546 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10547 wxString *arg2 = 0 ;
10548 wxString result;
10549 void *argp1 = 0 ;
10550 int res1 = 0 ;
10551 bool temp2 = false ;
10552 PyObject * obj0 = 0 ;
10553 PyObject * obj1 = 0 ;
10554 char * kwnames[] = {
10555 (char *) "self",(char *) "location", NULL
10556 };
10557
10558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10560 if (!SWIG_IsOK(res1)) {
10561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10562 }
10563 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10564 {
10565 arg2 = wxString_in_helper(obj1);
10566 if (arg2 == NULL) SWIG_fail;
10567 temp2 = true;
10568 }
10569 {
10570 PyThreadState* __tstate = wxPyBeginAllowThreads();
10571 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10572 wxPyEndAllowThreads(__tstate);
10573 if (PyErr_Occurred()) SWIG_fail;
10574 }
10575 {
10576 #if wxUSE_UNICODE
10577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10578 #else
10579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10580 #endif
10581 }
10582 {
10583 if (temp2)
10584 delete arg2;
10585 }
10586 return resultobj;
10587 fail:
10588 {
10589 if (temp2)
10590 delete arg2;
10591 }
10592 return NULL;
10593 }
10594
10595
10596 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10597 PyObject *obj;
10598 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10599 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10600 return SWIG_Py_Void();
10601 }
10602
10603 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10604 return SWIG_Python_InitShadowInstance(args);
10605 }
10606
10607 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10608 PyObject *resultobj = 0;
10609 wxFileSystem *result = 0 ;
10610
10611 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10612 {
10613 PyThreadState* __tstate = wxPyBeginAllowThreads();
10614 result = (wxFileSystem *)new wxFileSystem();
10615 wxPyEndAllowThreads(__tstate);
10616 if (PyErr_Occurred()) SWIG_fail;
10617 }
10618 {
10619 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10620 }
10621 return resultobj;
10622 fail:
10623 return NULL;
10624 }
10625
10626
10627 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10628 PyObject *resultobj = 0;
10629 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10630 void *argp1 = 0 ;
10631 int res1 = 0 ;
10632 PyObject *swig_obj[1] ;
10633
10634 if (!args) SWIG_fail;
10635 swig_obj[0] = args;
10636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10637 if (!SWIG_IsOK(res1)) {
10638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10639 }
10640 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10641 {
10642 PyThreadState* __tstate = wxPyBeginAllowThreads();
10643 delete arg1;
10644
10645 wxPyEndAllowThreads(__tstate);
10646 if (PyErr_Occurred()) SWIG_fail;
10647 }
10648 resultobj = SWIG_Py_Void();
10649 return resultobj;
10650 fail:
10651 return NULL;
10652 }
10653
10654
10655 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10656 PyObject *resultobj = 0;
10657 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10658 wxString *arg2 = 0 ;
10659 bool arg3 = (bool) false ;
10660 void *argp1 = 0 ;
10661 int res1 = 0 ;
10662 bool temp2 = false ;
10663 bool val3 ;
10664 int ecode3 = 0 ;
10665 PyObject * obj0 = 0 ;
10666 PyObject * obj1 = 0 ;
10667 PyObject * obj2 = 0 ;
10668 char * kwnames[] = {
10669 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10670 };
10671
10672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10674 if (!SWIG_IsOK(res1)) {
10675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10676 }
10677 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10678 {
10679 arg2 = wxString_in_helper(obj1);
10680 if (arg2 == NULL) SWIG_fail;
10681 temp2 = true;
10682 }
10683 if (obj2) {
10684 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10685 if (!SWIG_IsOK(ecode3)) {
10686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10687 }
10688 arg3 = static_cast< bool >(val3);
10689 }
10690 {
10691 PyThreadState* __tstate = wxPyBeginAllowThreads();
10692 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10693 wxPyEndAllowThreads(__tstate);
10694 if (PyErr_Occurred()) SWIG_fail;
10695 }
10696 resultobj = SWIG_Py_Void();
10697 {
10698 if (temp2)
10699 delete arg2;
10700 }
10701 return resultobj;
10702 fail:
10703 {
10704 if (temp2)
10705 delete arg2;
10706 }
10707 return NULL;
10708 }
10709
10710
10711 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10712 PyObject *resultobj = 0;
10713 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10714 wxString result;
10715 void *argp1 = 0 ;
10716 int res1 = 0 ;
10717 PyObject *swig_obj[1] ;
10718
10719 if (!args) SWIG_fail;
10720 swig_obj[0] = args;
10721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10722 if (!SWIG_IsOK(res1)) {
10723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10724 }
10725 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10726 {
10727 PyThreadState* __tstate = wxPyBeginAllowThreads();
10728 result = (arg1)->GetPath();
10729 wxPyEndAllowThreads(__tstate);
10730 if (PyErr_Occurred()) SWIG_fail;
10731 }
10732 {
10733 #if wxUSE_UNICODE
10734 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10735 #else
10736 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10737 #endif
10738 }
10739 return resultobj;
10740 fail:
10741 return NULL;
10742 }
10743
10744
10745 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10746 PyObject *resultobj = 0;
10747 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10748 wxString *arg2 = 0 ;
10749 wxFSFile *result = 0 ;
10750 void *argp1 = 0 ;
10751 int res1 = 0 ;
10752 bool temp2 = false ;
10753 PyObject * obj0 = 0 ;
10754 PyObject * obj1 = 0 ;
10755 char * kwnames[] = {
10756 (char *) "self",(char *) "location", NULL
10757 };
10758
10759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10761 if (!SWIG_IsOK(res1)) {
10762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10763 }
10764 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10765 {
10766 arg2 = wxString_in_helper(obj1);
10767 if (arg2 == NULL) SWIG_fail;
10768 temp2 = true;
10769 }
10770 {
10771 PyThreadState* __tstate = wxPyBeginAllowThreads();
10772 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10773 wxPyEndAllowThreads(__tstate);
10774 if (PyErr_Occurred()) SWIG_fail;
10775 }
10776 {
10777 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10778 }
10779 {
10780 if (temp2)
10781 delete arg2;
10782 }
10783 return resultobj;
10784 fail:
10785 {
10786 if (temp2)
10787 delete arg2;
10788 }
10789 return NULL;
10790 }
10791
10792
10793 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10794 PyObject *resultobj = 0;
10795 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10796 wxString *arg2 = 0 ;
10797 int arg3 = (int) 0 ;
10798 wxString result;
10799 void *argp1 = 0 ;
10800 int res1 = 0 ;
10801 bool temp2 = false ;
10802 int val3 ;
10803 int ecode3 = 0 ;
10804 PyObject * obj0 = 0 ;
10805 PyObject * obj1 = 0 ;
10806 PyObject * obj2 = 0 ;
10807 char * kwnames[] = {
10808 (char *) "self",(char *) "spec",(char *) "flags", NULL
10809 };
10810
10811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10813 if (!SWIG_IsOK(res1)) {
10814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10815 }
10816 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10817 {
10818 arg2 = wxString_in_helper(obj1);
10819 if (arg2 == NULL) SWIG_fail;
10820 temp2 = true;
10821 }
10822 if (obj2) {
10823 ecode3 = SWIG_AsVal_int(obj2, &val3);
10824 if (!SWIG_IsOK(ecode3)) {
10825 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10826 }
10827 arg3 = static_cast< int >(val3);
10828 }
10829 {
10830 PyThreadState* __tstate = wxPyBeginAllowThreads();
10831 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10832 wxPyEndAllowThreads(__tstate);
10833 if (PyErr_Occurred()) SWIG_fail;
10834 }
10835 {
10836 #if wxUSE_UNICODE
10837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10838 #else
10839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10840 #endif
10841 }
10842 {
10843 if (temp2)
10844 delete arg2;
10845 }
10846 return resultobj;
10847 fail:
10848 {
10849 if (temp2)
10850 delete arg2;
10851 }
10852 return NULL;
10853 }
10854
10855
10856 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10857 PyObject *resultobj = 0;
10858 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10859 wxString result;
10860 void *argp1 = 0 ;
10861 int res1 = 0 ;
10862 PyObject *swig_obj[1] ;
10863
10864 if (!args) SWIG_fail;
10865 swig_obj[0] = args;
10866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10867 if (!SWIG_IsOK(res1)) {
10868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10869 }
10870 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10871 {
10872 PyThreadState* __tstate = wxPyBeginAllowThreads();
10873 result = (arg1)->FindNext();
10874 wxPyEndAllowThreads(__tstate);
10875 if (PyErr_Occurred()) SWIG_fail;
10876 }
10877 {
10878 #if wxUSE_UNICODE
10879 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10880 #else
10881 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10882 #endif
10883 }
10884 return resultobj;
10885 fail:
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = 0;
10892 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10893 int res1 = 0 ;
10894 PyObject * obj0 = 0 ;
10895 char * kwnames[] = {
10896 (char *) "handler", NULL
10897 };
10898
10899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10900 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10901 if (!SWIG_IsOK(res1)) {
10902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10903 }
10904 {
10905 PyThreadState* __tstate = wxPyBeginAllowThreads();
10906 wxFileSystem::AddHandler(arg1);
10907 wxPyEndAllowThreads(__tstate);
10908 if (PyErr_Occurred()) SWIG_fail;
10909 }
10910 resultobj = SWIG_Py_Void();
10911 return resultobj;
10912 fail:
10913 return NULL;
10914 }
10915
10916
10917 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10918 PyObject *resultobj = 0;
10919 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10920 wxFileSystemHandler *result = 0 ;
10921 void *argp1 = 0 ;
10922 int res1 = 0 ;
10923 PyObject * obj0 = 0 ;
10924 char * kwnames[] = {
10925 (char *) "handler", NULL
10926 };
10927
10928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
10929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10930 if (!SWIG_IsOK(res1)) {
10931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10932 }
10933 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10934 {
10935 PyThreadState* __tstate = wxPyBeginAllowThreads();
10936 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
10937 wxPyEndAllowThreads(__tstate);
10938 if (PyErr_Occurred()) SWIG_fail;
10939 }
10940 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10948 PyObject *resultobj = 0;
10949
10950 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10951 {
10952 PyThreadState* __tstate = wxPyBeginAllowThreads();
10953 wxFileSystem::CleanUpHandlers();
10954 wxPyEndAllowThreads(__tstate);
10955 if (PyErr_Occurred()) SWIG_fail;
10956 }
10957 resultobj = SWIG_Py_Void();
10958 return resultobj;
10959 fail:
10960 return NULL;
10961 }
10962
10963
10964 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10965 PyObject *resultobj = 0;
10966 wxString *arg1 = 0 ;
10967 wxString result;
10968 bool temp1 = false ;
10969 PyObject * obj0 = 0 ;
10970 char * kwnames[] = {
10971 (char *) "filename", NULL
10972 };
10973
10974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10975 {
10976 arg1 = wxString_in_helper(obj0);
10977 if (arg1 == NULL) SWIG_fail;
10978 temp1 = true;
10979 }
10980 {
10981 PyThreadState* __tstate = wxPyBeginAllowThreads();
10982 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10983 wxPyEndAllowThreads(__tstate);
10984 if (PyErr_Occurred()) SWIG_fail;
10985 }
10986 {
10987 #if wxUSE_UNICODE
10988 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10989 #else
10990 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10991 #endif
10992 }
10993 {
10994 if (temp1)
10995 delete arg1;
10996 }
10997 return resultobj;
10998 fail:
10999 {
11000 if (temp1)
11001 delete arg1;
11002 }
11003 return NULL;
11004 }
11005
11006
11007 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11008 PyObject *resultobj = 0;
11009 wxString *arg1 = 0 ;
11010 wxString result;
11011 bool temp1 = false ;
11012 PyObject * obj0 = 0 ;
11013 char * kwnames[] = {
11014 (char *) "url", NULL
11015 };
11016
11017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
11018 {
11019 arg1 = wxString_in_helper(obj0);
11020 if (arg1 == NULL) SWIG_fail;
11021 temp1 = true;
11022 }
11023 {
11024 PyThreadState* __tstate = wxPyBeginAllowThreads();
11025 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
11026 wxPyEndAllowThreads(__tstate);
11027 if (PyErr_Occurred()) SWIG_fail;
11028 }
11029 {
11030 #if wxUSE_UNICODE
11031 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11032 #else
11033 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11034 #endif
11035 }
11036 {
11037 if (temp1)
11038 delete arg1;
11039 }
11040 return resultobj;
11041 fail:
11042 {
11043 if (temp1)
11044 delete arg1;
11045 }
11046 return NULL;
11047 }
11048
11049
11050 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11051 PyObject *obj;
11052 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11053 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
11054 return SWIG_Py_Void();
11055 }
11056
11057 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11058 return SWIG_Python_InitShadowInstance(args);
11059 }
11060
11061 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11062 PyObject *resultobj = 0;
11063 wxInternetFSHandler *result = 0 ;
11064
11065 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
11066 {
11067 PyThreadState* __tstate = wxPyBeginAllowThreads();
11068 result = (wxInternetFSHandler *)new wxInternetFSHandler();
11069 wxPyEndAllowThreads(__tstate);
11070 if (PyErr_Occurred()) SWIG_fail;
11071 }
11072 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
11073 return resultobj;
11074 fail:
11075 return NULL;
11076 }
11077
11078
11079 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11080 PyObject *resultobj = 0;
11081 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11082 wxString *arg2 = 0 ;
11083 bool result;
11084 void *argp1 = 0 ;
11085 int res1 = 0 ;
11086 bool temp2 = false ;
11087 PyObject * obj0 = 0 ;
11088 PyObject * obj1 = 0 ;
11089 char * kwnames[] = {
11090 (char *) "self",(char *) "location", NULL
11091 };
11092
11093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11095 if (!SWIG_IsOK(res1)) {
11096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11097 }
11098 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11099 {
11100 arg2 = wxString_in_helper(obj1);
11101 if (arg2 == NULL) SWIG_fail;
11102 temp2 = true;
11103 }
11104 {
11105 PyThreadState* __tstate = wxPyBeginAllowThreads();
11106 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11107 wxPyEndAllowThreads(__tstate);
11108 if (PyErr_Occurred()) SWIG_fail;
11109 }
11110 {
11111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11112 }
11113 {
11114 if (temp2)
11115 delete arg2;
11116 }
11117 return resultobj;
11118 fail:
11119 {
11120 if (temp2)
11121 delete arg2;
11122 }
11123 return NULL;
11124 }
11125
11126
11127 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11128 PyObject *resultobj = 0;
11129 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11130 wxFileSystem *arg2 = 0 ;
11131 wxString *arg3 = 0 ;
11132 wxFSFile *result = 0 ;
11133 void *argp1 = 0 ;
11134 int res1 = 0 ;
11135 void *argp2 = 0 ;
11136 int res2 = 0 ;
11137 bool temp3 = false ;
11138 PyObject * obj0 = 0 ;
11139 PyObject * obj1 = 0 ;
11140 PyObject * obj2 = 0 ;
11141 char * kwnames[] = {
11142 (char *) "self",(char *) "fs",(char *) "location", NULL
11143 };
11144
11145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11147 if (!SWIG_IsOK(res1)) {
11148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11149 }
11150 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11151 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11152 if (!SWIG_IsOK(res2)) {
11153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11154 }
11155 if (!argp2) {
11156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11157 }
11158 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11159 {
11160 arg3 = wxString_in_helper(obj2);
11161 if (arg3 == NULL) SWIG_fail;
11162 temp3 = true;
11163 }
11164 {
11165 PyThreadState* __tstate = wxPyBeginAllowThreads();
11166 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11167 wxPyEndAllowThreads(__tstate);
11168 if (PyErr_Occurred()) SWIG_fail;
11169 }
11170 {
11171 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11172 }
11173 {
11174 if (temp3)
11175 delete arg3;
11176 }
11177 return resultobj;
11178 fail:
11179 {
11180 if (temp3)
11181 delete arg3;
11182 }
11183 return NULL;
11184 }
11185
11186
11187 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11188 PyObject *obj;
11189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11190 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11191 return SWIG_Py_Void();
11192 }
11193
11194 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11195 return SWIG_Python_InitShadowInstance(args);
11196 }
11197
11198 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11199 PyObject *resultobj = 0;
11200 wxZipFSHandler *result = 0 ;
11201
11202 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11203 {
11204 PyThreadState* __tstate = wxPyBeginAllowThreads();
11205 result = (wxZipFSHandler *)new wxZipFSHandler();
11206 wxPyEndAllowThreads(__tstate);
11207 if (PyErr_Occurred()) SWIG_fail;
11208 }
11209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11210 return resultobj;
11211 fail:
11212 return NULL;
11213 }
11214
11215
11216 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11217 PyObject *resultobj = 0;
11218 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11219 wxString *arg2 = 0 ;
11220 bool result;
11221 void *argp1 = 0 ;
11222 int res1 = 0 ;
11223 bool temp2 = false ;
11224 PyObject * obj0 = 0 ;
11225 PyObject * obj1 = 0 ;
11226 char * kwnames[] = {
11227 (char *) "self",(char *) "location", NULL
11228 };
11229
11230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11232 if (!SWIG_IsOK(res1)) {
11233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11234 }
11235 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11236 {
11237 arg2 = wxString_in_helper(obj1);
11238 if (arg2 == NULL) SWIG_fail;
11239 temp2 = true;
11240 }
11241 {
11242 PyThreadState* __tstate = wxPyBeginAllowThreads();
11243 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11244 wxPyEndAllowThreads(__tstate);
11245 if (PyErr_Occurred()) SWIG_fail;
11246 }
11247 {
11248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11249 }
11250 {
11251 if (temp2)
11252 delete arg2;
11253 }
11254 return resultobj;
11255 fail:
11256 {
11257 if (temp2)
11258 delete arg2;
11259 }
11260 return NULL;
11261 }
11262
11263
11264 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11265 PyObject *resultobj = 0;
11266 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11267 wxFileSystem *arg2 = 0 ;
11268 wxString *arg3 = 0 ;
11269 wxFSFile *result = 0 ;
11270 void *argp1 = 0 ;
11271 int res1 = 0 ;
11272 void *argp2 = 0 ;
11273 int res2 = 0 ;
11274 bool temp3 = false ;
11275 PyObject * obj0 = 0 ;
11276 PyObject * obj1 = 0 ;
11277 PyObject * obj2 = 0 ;
11278 char * kwnames[] = {
11279 (char *) "self",(char *) "fs",(char *) "location", NULL
11280 };
11281
11282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11284 if (!SWIG_IsOK(res1)) {
11285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11286 }
11287 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11288 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11289 if (!SWIG_IsOK(res2)) {
11290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11291 }
11292 if (!argp2) {
11293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11294 }
11295 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11296 {
11297 arg3 = wxString_in_helper(obj2);
11298 if (arg3 == NULL) SWIG_fail;
11299 temp3 = true;
11300 }
11301 {
11302 PyThreadState* __tstate = wxPyBeginAllowThreads();
11303 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11304 wxPyEndAllowThreads(__tstate);
11305 if (PyErr_Occurred()) SWIG_fail;
11306 }
11307 {
11308 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11309 }
11310 {
11311 if (temp3)
11312 delete arg3;
11313 }
11314 return resultobj;
11315 fail:
11316 {
11317 if (temp3)
11318 delete arg3;
11319 }
11320 return NULL;
11321 }
11322
11323
11324 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11325 PyObject *resultobj = 0;
11326 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11327 wxString *arg2 = 0 ;
11328 int arg3 = (int) 0 ;
11329 wxString result;
11330 void *argp1 = 0 ;
11331 int res1 = 0 ;
11332 bool temp2 = false ;
11333 int val3 ;
11334 int ecode3 = 0 ;
11335 PyObject * obj0 = 0 ;
11336 PyObject * obj1 = 0 ;
11337 PyObject * obj2 = 0 ;
11338 char * kwnames[] = {
11339 (char *) "self",(char *) "spec",(char *) "flags", NULL
11340 };
11341
11342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11344 if (!SWIG_IsOK(res1)) {
11345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11346 }
11347 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11348 {
11349 arg2 = wxString_in_helper(obj1);
11350 if (arg2 == NULL) SWIG_fail;
11351 temp2 = true;
11352 }
11353 if (obj2) {
11354 ecode3 = SWIG_AsVal_int(obj2, &val3);
11355 if (!SWIG_IsOK(ecode3)) {
11356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11357 }
11358 arg3 = static_cast< int >(val3);
11359 }
11360 {
11361 PyThreadState* __tstate = wxPyBeginAllowThreads();
11362 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11363 wxPyEndAllowThreads(__tstate);
11364 if (PyErr_Occurred()) SWIG_fail;
11365 }
11366 {
11367 #if wxUSE_UNICODE
11368 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11369 #else
11370 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11371 #endif
11372 }
11373 {
11374 if (temp2)
11375 delete arg2;
11376 }
11377 return resultobj;
11378 fail:
11379 {
11380 if (temp2)
11381 delete arg2;
11382 }
11383 return NULL;
11384 }
11385
11386
11387 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11388 PyObject *resultobj = 0;
11389 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11390 wxString result;
11391 void *argp1 = 0 ;
11392 int res1 = 0 ;
11393 PyObject *swig_obj[1] ;
11394
11395 if (!args) SWIG_fail;
11396 swig_obj[0] = args;
11397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11398 if (!SWIG_IsOK(res1)) {
11399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11400 }
11401 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11402 {
11403 PyThreadState* __tstate = wxPyBeginAllowThreads();
11404 result = (arg1)->FindNext();
11405 wxPyEndAllowThreads(__tstate);
11406 if (PyErr_Occurred()) SWIG_fail;
11407 }
11408 {
11409 #if wxUSE_UNICODE
11410 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11411 #else
11412 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11413 #endif
11414 }
11415 return resultobj;
11416 fail:
11417 return NULL;
11418 }
11419
11420
11421 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11422 PyObject *obj;
11423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11424 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11425 return SWIG_Py_Void();
11426 }
11427
11428 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11429 return SWIG_Python_InitShadowInstance(args);
11430 }
11431
11432 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11433 PyObject *resultobj = 0;
11434 wxString *arg1 = 0 ;
11435 wxImage *arg2 = 0 ;
11436 long arg3 ;
11437 bool temp1 = false ;
11438 void *argp2 = 0 ;
11439 int res2 = 0 ;
11440 long val3 ;
11441 int ecode3 = 0 ;
11442 PyObject * obj0 = 0 ;
11443 PyObject * obj1 = 0 ;
11444 PyObject * obj2 = 0 ;
11445 char * kwnames[] = {
11446 (char *) "filename",(char *) "image",(char *) "type", NULL
11447 };
11448
11449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11450 {
11451 arg1 = wxString_in_helper(obj0);
11452 if (arg1 == NULL) SWIG_fail;
11453 temp1 = true;
11454 }
11455 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11456 if (!SWIG_IsOK(res2)) {
11457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11458 }
11459 if (!argp2) {
11460 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11461 }
11462 arg2 = reinterpret_cast< wxImage * >(argp2);
11463 ecode3 = SWIG_AsVal_long(obj2, &val3);
11464 if (!SWIG_IsOK(ecode3)) {
11465 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11466 }
11467 arg3 = static_cast< long >(val3);
11468 {
11469 PyThreadState* __tstate = wxPyBeginAllowThreads();
11470 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11471 wxPyEndAllowThreads(__tstate);
11472 if (PyErr_Occurred()) SWIG_fail;
11473 }
11474 resultobj = SWIG_Py_Void();
11475 {
11476 if (temp1)
11477 delete arg1;
11478 }
11479 return resultobj;
11480 fail:
11481 {
11482 if (temp1)
11483 delete arg1;
11484 }
11485 return NULL;
11486 }
11487
11488
11489 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11490 PyObject *resultobj = 0;
11491 wxString *arg1 = 0 ;
11492 wxBitmap *arg2 = 0 ;
11493 long arg3 ;
11494 bool temp1 = false ;
11495 void *argp2 = 0 ;
11496 int res2 = 0 ;
11497 long val3 ;
11498 int ecode3 = 0 ;
11499 PyObject * obj0 = 0 ;
11500 PyObject * obj1 = 0 ;
11501 PyObject * obj2 = 0 ;
11502 char * kwnames[] = {
11503 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11504 };
11505
11506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11507 {
11508 arg1 = wxString_in_helper(obj0);
11509 if (arg1 == NULL) SWIG_fail;
11510 temp1 = true;
11511 }
11512 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11513 if (!SWIG_IsOK(res2)) {
11514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11515 }
11516 if (!argp2) {
11517 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11518 }
11519 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11520 ecode3 = SWIG_AsVal_long(obj2, &val3);
11521 if (!SWIG_IsOK(ecode3)) {
11522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11523 }
11524 arg3 = static_cast< long >(val3);
11525 {
11526 PyThreadState* __tstate = wxPyBeginAllowThreads();
11527 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11528 wxPyEndAllowThreads(__tstate);
11529 if (PyErr_Occurred()) SWIG_fail;
11530 }
11531 resultobj = SWIG_Py_Void();
11532 {
11533 if (temp1)
11534 delete arg1;
11535 }
11536 return resultobj;
11537 fail:
11538 {
11539 if (temp1)
11540 delete arg1;
11541 }
11542 return NULL;
11543 }
11544
11545
11546 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11547 PyObject *resultobj = 0;
11548 wxString *arg1 = 0 ;
11549 PyObject *arg2 = (PyObject *) 0 ;
11550 bool temp1 = false ;
11551 PyObject * obj0 = 0 ;
11552 PyObject * obj1 = 0 ;
11553 char * kwnames[] = {
11554 (char *) "filename",(char *) "data", NULL
11555 };
11556
11557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11558 {
11559 arg1 = wxString_in_helper(obj0);
11560 if (arg1 == NULL) SWIG_fail;
11561 temp1 = true;
11562 }
11563 arg2 = obj1;
11564 {
11565 PyThreadState* __tstate = wxPyBeginAllowThreads();
11566 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11567 wxPyEndAllowThreads(__tstate);
11568 if (PyErr_Occurred()) SWIG_fail;
11569 }
11570 resultobj = SWIG_Py_Void();
11571 {
11572 if (temp1)
11573 delete arg1;
11574 }
11575 return resultobj;
11576 fail:
11577 {
11578 if (temp1)
11579 delete arg1;
11580 }
11581 return NULL;
11582 }
11583
11584
11585 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11586 PyObject *resultobj = 0;
11587 wxMemoryFSHandler *result = 0 ;
11588
11589 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11590 {
11591 PyThreadState* __tstate = wxPyBeginAllowThreads();
11592 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11593 wxPyEndAllowThreads(__tstate);
11594 if (PyErr_Occurred()) SWIG_fail;
11595 }
11596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11597 return resultobj;
11598 fail:
11599 return NULL;
11600 }
11601
11602
11603 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11604 PyObject *resultobj = 0;
11605 wxString *arg1 = 0 ;
11606 bool temp1 = false ;
11607 PyObject * obj0 = 0 ;
11608 char * kwnames[] = {
11609 (char *) "filename", NULL
11610 };
11611
11612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11613 {
11614 arg1 = wxString_in_helper(obj0);
11615 if (arg1 == NULL) SWIG_fail;
11616 temp1 = true;
11617 }
11618 {
11619 PyThreadState* __tstate = wxPyBeginAllowThreads();
11620 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11621 wxPyEndAllowThreads(__tstate);
11622 if (PyErr_Occurred()) SWIG_fail;
11623 }
11624 resultobj = SWIG_Py_Void();
11625 {
11626 if (temp1)
11627 delete arg1;
11628 }
11629 return resultobj;
11630 fail:
11631 {
11632 if (temp1)
11633 delete arg1;
11634 }
11635 return NULL;
11636 }
11637
11638
11639 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11640 PyObject *resultobj = 0;
11641 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11642 wxString *arg2 = 0 ;
11643 bool result;
11644 void *argp1 = 0 ;
11645 int res1 = 0 ;
11646 bool temp2 = false ;
11647 PyObject * obj0 = 0 ;
11648 PyObject * obj1 = 0 ;
11649 char * kwnames[] = {
11650 (char *) "self",(char *) "location", NULL
11651 };
11652
11653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11655 if (!SWIG_IsOK(res1)) {
11656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11657 }
11658 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11659 {
11660 arg2 = wxString_in_helper(obj1);
11661 if (arg2 == NULL) SWIG_fail;
11662 temp2 = true;
11663 }
11664 {
11665 PyThreadState* __tstate = wxPyBeginAllowThreads();
11666 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11667 wxPyEndAllowThreads(__tstate);
11668 if (PyErr_Occurred()) SWIG_fail;
11669 }
11670 {
11671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11672 }
11673 {
11674 if (temp2)
11675 delete arg2;
11676 }
11677 return resultobj;
11678 fail:
11679 {
11680 if (temp2)
11681 delete arg2;
11682 }
11683 return NULL;
11684 }
11685
11686
11687 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11688 PyObject *resultobj = 0;
11689 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11690 wxFileSystem *arg2 = 0 ;
11691 wxString *arg3 = 0 ;
11692 wxFSFile *result = 0 ;
11693 void *argp1 = 0 ;
11694 int res1 = 0 ;
11695 void *argp2 = 0 ;
11696 int res2 = 0 ;
11697 bool temp3 = false ;
11698 PyObject * obj0 = 0 ;
11699 PyObject * obj1 = 0 ;
11700 PyObject * obj2 = 0 ;
11701 char * kwnames[] = {
11702 (char *) "self",(char *) "fs",(char *) "location", NULL
11703 };
11704
11705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11707 if (!SWIG_IsOK(res1)) {
11708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11709 }
11710 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11711 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11712 if (!SWIG_IsOK(res2)) {
11713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11714 }
11715 if (!argp2) {
11716 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11717 }
11718 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11719 {
11720 arg3 = wxString_in_helper(obj2);
11721 if (arg3 == NULL) SWIG_fail;
11722 temp3 = true;
11723 }
11724 {
11725 PyThreadState* __tstate = wxPyBeginAllowThreads();
11726 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11727 wxPyEndAllowThreads(__tstate);
11728 if (PyErr_Occurred()) SWIG_fail;
11729 }
11730 {
11731 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11732 }
11733 {
11734 if (temp3)
11735 delete arg3;
11736 }
11737 return resultobj;
11738 fail:
11739 {
11740 if (temp3)
11741 delete arg3;
11742 }
11743 return NULL;
11744 }
11745
11746
11747 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11748 PyObject *resultobj = 0;
11749 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11750 wxString *arg2 = 0 ;
11751 int arg3 = (int) 0 ;
11752 wxString result;
11753 void *argp1 = 0 ;
11754 int res1 = 0 ;
11755 bool temp2 = false ;
11756 int val3 ;
11757 int ecode3 = 0 ;
11758 PyObject * obj0 = 0 ;
11759 PyObject * obj1 = 0 ;
11760 PyObject * obj2 = 0 ;
11761 char * kwnames[] = {
11762 (char *) "self",(char *) "spec",(char *) "flags", NULL
11763 };
11764
11765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11767 if (!SWIG_IsOK(res1)) {
11768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11769 }
11770 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11771 {
11772 arg2 = wxString_in_helper(obj1);
11773 if (arg2 == NULL) SWIG_fail;
11774 temp2 = true;
11775 }
11776 if (obj2) {
11777 ecode3 = SWIG_AsVal_int(obj2, &val3);
11778 if (!SWIG_IsOK(ecode3)) {
11779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11780 }
11781 arg3 = static_cast< int >(val3);
11782 }
11783 {
11784 PyThreadState* __tstate = wxPyBeginAllowThreads();
11785 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11786 wxPyEndAllowThreads(__tstate);
11787 if (PyErr_Occurred()) SWIG_fail;
11788 }
11789 {
11790 #if wxUSE_UNICODE
11791 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11792 #else
11793 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11794 #endif
11795 }
11796 {
11797 if (temp2)
11798 delete arg2;
11799 }
11800 return resultobj;
11801 fail:
11802 {
11803 if (temp2)
11804 delete arg2;
11805 }
11806 return NULL;
11807 }
11808
11809
11810 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11811 PyObject *resultobj = 0;
11812 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11813 wxString result;
11814 void *argp1 = 0 ;
11815 int res1 = 0 ;
11816 PyObject *swig_obj[1] ;
11817
11818 if (!args) SWIG_fail;
11819 swig_obj[0] = args;
11820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11821 if (!SWIG_IsOK(res1)) {
11822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11823 }
11824 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11825 {
11826 PyThreadState* __tstate = wxPyBeginAllowThreads();
11827 result = (arg1)->FindNext();
11828 wxPyEndAllowThreads(__tstate);
11829 if (PyErr_Occurred()) SWIG_fail;
11830 }
11831 {
11832 #if wxUSE_UNICODE
11833 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11834 #else
11835 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11836 #endif
11837 }
11838 return resultobj;
11839 fail:
11840 return NULL;
11841 }
11842
11843
11844 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11845 PyObject *obj;
11846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11847 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11848 return SWIG_Py_Void();
11849 }
11850
11851 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11852 return SWIG_Python_InitShadowInstance(args);
11853 }
11854
11855 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11856 PyObject *resultobj = 0;
11857 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11858 wxString result;
11859 void *argp1 = 0 ;
11860 int res1 = 0 ;
11861 PyObject *swig_obj[1] ;
11862
11863 if (!args) SWIG_fail;
11864 swig_obj[0] = args;
11865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11866 if (!SWIG_IsOK(res1)) {
11867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11868 }
11869 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11870 {
11871 PyThreadState* __tstate = wxPyBeginAllowThreads();
11872 result = (arg1)->GetName();
11873 wxPyEndAllowThreads(__tstate);
11874 if (PyErr_Occurred()) SWIG_fail;
11875 }
11876 {
11877 #if wxUSE_UNICODE
11878 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11879 #else
11880 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11881 #endif
11882 }
11883 return resultobj;
11884 fail:
11885 return NULL;
11886 }
11887
11888
11889 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11890 PyObject *resultobj = 0;
11891 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11892 wxString result;
11893 void *argp1 = 0 ;
11894 int res1 = 0 ;
11895 PyObject *swig_obj[1] ;
11896
11897 if (!args) SWIG_fail;
11898 swig_obj[0] = args;
11899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11900 if (!SWIG_IsOK(res1)) {
11901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11902 }
11903 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11904 {
11905 PyThreadState* __tstate = wxPyBeginAllowThreads();
11906 result = (arg1)->GetExtension();
11907 wxPyEndAllowThreads(__tstate);
11908 if (PyErr_Occurred()) SWIG_fail;
11909 }
11910 {
11911 #if wxUSE_UNICODE
11912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11913 #else
11914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11915 #endif
11916 }
11917 return resultobj;
11918 fail:
11919 return NULL;
11920 }
11921
11922
11923 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11924 PyObject *resultobj = 0;
11925 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11926 long result;
11927 void *argp1 = 0 ;
11928 int res1 = 0 ;
11929 PyObject *swig_obj[1] ;
11930
11931 if (!args) SWIG_fail;
11932 swig_obj[0] = args;
11933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11934 if (!SWIG_IsOK(res1)) {
11935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11936 }
11937 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11938 {
11939 PyThreadState* __tstate = wxPyBeginAllowThreads();
11940 result = (long)(arg1)->GetType();
11941 wxPyEndAllowThreads(__tstate);
11942 if (PyErr_Occurred()) SWIG_fail;
11943 }
11944 resultobj = SWIG_From_long(static_cast< long >(result));
11945 return resultobj;
11946 fail:
11947 return NULL;
11948 }
11949
11950
11951 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11952 PyObject *resultobj = 0;
11953 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11954 wxString result;
11955 void *argp1 = 0 ;
11956 int res1 = 0 ;
11957 PyObject *swig_obj[1] ;
11958
11959 if (!args) SWIG_fail;
11960 swig_obj[0] = args;
11961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11962 if (!SWIG_IsOK(res1)) {
11963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11964 }
11965 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11966 {
11967 PyThreadState* __tstate = wxPyBeginAllowThreads();
11968 result = (arg1)->GetMimeType();
11969 wxPyEndAllowThreads(__tstate);
11970 if (PyErr_Occurred()) SWIG_fail;
11971 }
11972 {
11973 #if wxUSE_UNICODE
11974 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11975 #else
11976 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11977 #endif
11978 }
11979 return resultobj;
11980 fail:
11981 return NULL;
11982 }
11983
11984
11985 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11986 PyObject *resultobj = 0;
11987 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11988 wxString *arg2 = 0 ;
11989 bool result;
11990 void *argp1 = 0 ;
11991 int res1 = 0 ;
11992 bool temp2 = false ;
11993 PyObject * obj0 = 0 ;
11994 PyObject * obj1 = 0 ;
11995 char * kwnames[] = {
11996 (char *) "self",(char *) "name", NULL
11997 };
11998
11999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
12000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12001 if (!SWIG_IsOK(res1)) {
12002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12003 }
12004 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12005 {
12006 arg2 = wxString_in_helper(obj1);
12007 if (arg2 == NULL) SWIG_fail;
12008 temp2 = true;
12009 }
12010 {
12011 PyThreadState* __tstate = wxPyBeginAllowThreads();
12012 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
12013 wxPyEndAllowThreads(__tstate);
12014 if (PyErr_Occurred()) SWIG_fail;
12015 }
12016 {
12017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12018 }
12019 {
12020 if (temp2)
12021 delete arg2;
12022 }
12023 return resultobj;
12024 fail:
12025 {
12026 if (temp2)
12027 delete arg2;
12028 }
12029 return NULL;
12030 }
12031
12032
12033 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12034 PyObject *resultobj = 0;
12035 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12036 wxInputStream *arg2 = 0 ;
12037 bool result;
12038 void *argp1 = 0 ;
12039 int res1 = 0 ;
12040 wxPyInputStream *temp2 ;
12041 bool created2 ;
12042 PyObject * obj0 = 0 ;
12043 PyObject * obj1 = 0 ;
12044 char * kwnames[] = {
12045 (char *) "self",(char *) "stream", NULL
12046 };
12047
12048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
12049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12050 if (!SWIG_IsOK(res1)) {
12051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12052 }
12053 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12054 {
12055 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12056 arg2 = temp2->m_wxis;
12057 created2 = false;
12058 } else {
12059 PyErr_Clear(); // clear the failure of the wxPyConvert above
12060 arg2 = wxPyCBInputStream_create(obj1, false);
12061 if (arg2 == NULL) {
12062 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12063 SWIG_fail;
12064 }
12065 created2 = true;
12066 }
12067 }
12068 {
12069 PyThreadState* __tstate = wxPyBeginAllowThreads();
12070 result = (bool)(arg1)->CanRead(*arg2);
12071 wxPyEndAllowThreads(__tstate);
12072 if (PyErr_Occurred()) SWIG_fail;
12073 }
12074 {
12075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12076 }
12077 {
12078 if (created2) delete arg2;
12079 }
12080 return resultobj;
12081 fail:
12082 {
12083 if (created2) delete arg2;
12084 }
12085 return NULL;
12086 }
12087
12088
12089 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12090 PyObject *resultobj = 0;
12091 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12092 wxString *arg2 = 0 ;
12093 void *argp1 = 0 ;
12094 int res1 = 0 ;
12095 bool temp2 = false ;
12096 PyObject * obj0 = 0 ;
12097 PyObject * obj1 = 0 ;
12098 char * kwnames[] = {
12099 (char *) "self",(char *) "name", NULL
12100 };
12101
12102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
12103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12104 if (!SWIG_IsOK(res1)) {
12105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12106 }
12107 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12108 {
12109 arg2 = wxString_in_helper(obj1);
12110 if (arg2 == NULL) SWIG_fail;
12111 temp2 = true;
12112 }
12113 {
12114 PyThreadState* __tstate = wxPyBeginAllowThreads();
12115 (arg1)->SetName((wxString const &)*arg2);
12116 wxPyEndAllowThreads(__tstate);
12117 if (PyErr_Occurred()) SWIG_fail;
12118 }
12119 resultobj = SWIG_Py_Void();
12120 {
12121 if (temp2)
12122 delete arg2;
12123 }
12124 return resultobj;
12125 fail:
12126 {
12127 if (temp2)
12128 delete arg2;
12129 }
12130 return NULL;
12131 }
12132
12133
12134 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12135 PyObject *resultobj = 0;
12136 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12137 wxString *arg2 = 0 ;
12138 void *argp1 = 0 ;
12139 int res1 = 0 ;
12140 bool temp2 = false ;
12141 PyObject * obj0 = 0 ;
12142 PyObject * obj1 = 0 ;
12143 char * kwnames[] = {
12144 (char *) "self",(char *) "extension", NULL
12145 };
12146
12147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12149 if (!SWIG_IsOK(res1)) {
12150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12151 }
12152 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12153 {
12154 arg2 = wxString_in_helper(obj1);
12155 if (arg2 == NULL) SWIG_fail;
12156 temp2 = true;
12157 }
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 (arg1)->SetExtension((wxString const &)*arg2);
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 resultobj = SWIG_Py_Void();
12165 {
12166 if (temp2)
12167 delete arg2;
12168 }
12169 return resultobj;
12170 fail:
12171 {
12172 if (temp2)
12173 delete arg2;
12174 }
12175 return NULL;
12176 }
12177
12178
12179 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12180 PyObject *resultobj = 0;
12181 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12182 long arg2 ;
12183 void *argp1 = 0 ;
12184 int res1 = 0 ;
12185 long val2 ;
12186 int ecode2 = 0 ;
12187 PyObject * obj0 = 0 ;
12188 PyObject * obj1 = 0 ;
12189 char * kwnames[] = {
12190 (char *) "self",(char *) "type", NULL
12191 };
12192
12193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12195 if (!SWIG_IsOK(res1)) {
12196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12197 }
12198 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12199 ecode2 = SWIG_AsVal_long(obj1, &val2);
12200 if (!SWIG_IsOK(ecode2)) {
12201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12202 }
12203 arg2 = static_cast< long >(val2);
12204 {
12205 PyThreadState* __tstate = wxPyBeginAllowThreads();
12206 (arg1)->SetType(arg2);
12207 wxPyEndAllowThreads(__tstate);
12208 if (PyErr_Occurred()) SWIG_fail;
12209 }
12210 resultobj = SWIG_Py_Void();
12211 return resultobj;
12212 fail:
12213 return NULL;
12214 }
12215
12216
12217 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12218 PyObject *resultobj = 0;
12219 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12220 wxString *arg2 = 0 ;
12221 void *argp1 = 0 ;
12222 int res1 = 0 ;
12223 bool temp2 = false ;
12224 PyObject * obj0 = 0 ;
12225 PyObject * obj1 = 0 ;
12226 char * kwnames[] = {
12227 (char *) "self",(char *) "mimetype", NULL
12228 };
12229
12230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12232 if (!SWIG_IsOK(res1)) {
12233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12234 }
12235 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12236 {
12237 arg2 = wxString_in_helper(obj1);
12238 if (arg2 == NULL) SWIG_fail;
12239 temp2 = true;
12240 }
12241 {
12242 PyThreadState* __tstate = wxPyBeginAllowThreads();
12243 (arg1)->SetMimeType((wxString const &)*arg2);
12244 wxPyEndAllowThreads(__tstate);
12245 if (PyErr_Occurred()) SWIG_fail;
12246 }
12247 resultobj = SWIG_Py_Void();
12248 {
12249 if (temp2)
12250 delete arg2;
12251 }
12252 return resultobj;
12253 fail:
12254 {
12255 if (temp2)
12256 delete arg2;
12257 }
12258 return NULL;
12259 }
12260
12261
12262 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12263 PyObject *obj;
12264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12265 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12266 return SWIG_Py_Void();
12267 }
12268
12269 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12270 PyObject *resultobj = 0;
12271 wxPyImageHandler *result = 0 ;
12272
12273 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12274 {
12275 PyThreadState* __tstate = wxPyBeginAllowThreads();
12276 result = (wxPyImageHandler *)new wxPyImageHandler();
12277 wxPyEndAllowThreads(__tstate);
12278 if (PyErr_Occurred()) SWIG_fail;
12279 }
12280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12281 return resultobj;
12282 fail:
12283 return NULL;
12284 }
12285
12286
12287 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12288 PyObject *resultobj = 0;
12289 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12290 PyObject *arg2 = (PyObject *) 0 ;
12291 void *argp1 = 0 ;
12292 int res1 = 0 ;
12293 PyObject * obj0 = 0 ;
12294 PyObject * obj1 = 0 ;
12295 char * kwnames[] = {
12296 (char *) "self",(char *) "self", NULL
12297 };
12298
12299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12301 if (!SWIG_IsOK(res1)) {
12302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12303 }
12304 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12305 arg2 = obj1;
12306 {
12307 PyThreadState* __tstate = wxPyBeginAllowThreads();
12308 (arg1)->_SetSelf(arg2);
12309 wxPyEndAllowThreads(__tstate);
12310 if (PyErr_Occurred()) SWIG_fail;
12311 }
12312 resultobj = SWIG_Py_Void();
12313 return resultobj;
12314 fail:
12315 return NULL;
12316 }
12317
12318
12319 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12320 PyObject *obj;
12321 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12322 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12323 return SWIG_Py_Void();
12324 }
12325
12326 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12327 return SWIG_Python_InitShadowInstance(args);
12328 }
12329
12330 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12331 PyObject *resultobj = 0;
12332 wxImageHistogram *result = 0 ;
12333
12334 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12335 {
12336 PyThreadState* __tstate = wxPyBeginAllowThreads();
12337 result = (wxImageHistogram *)new wxImageHistogram();
12338 wxPyEndAllowThreads(__tstate);
12339 if (PyErr_Occurred()) SWIG_fail;
12340 }
12341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12342 return resultobj;
12343 fail:
12344 return NULL;
12345 }
12346
12347
12348 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12349 PyObject *resultobj = 0;
12350 byte arg1 ;
12351 byte arg2 ;
12352 byte arg3 ;
12353 unsigned long result;
12354 unsigned char val1 ;
12355 int ecode1 = 0 ;
12356 unsigned char val2 ;
12357 int ecode2 = 0 ;
12358 unsigned char val3 ;
12359 int ecode3 = 0 ;
12360 PyObject * obj0 = 0 ;
12361 PyObject * obj1 = 0 ;
12362 PyObject * obj2 = 0 ;
12363 char * kwnames[] = {
12364 (char *) "r",(char *) "g",(char *) "b", NULL
12365 };
12366
12367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12368 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12369 if (!SWIG_IsOK(ecode1)) {
12370 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12371 }
12372 arg1 = static_cast< byte >(val1);
12373 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12374 if (!SWIG_IsOK(ecode2)) {
12375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12376 }
12377 arg2 = static_cast< byte >(val2);
12378 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12379 if (!SWIG_IsOK(ecode3)) {
12380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12381 }
12382 arg3 = static_cast< byte >(val3);
12383 {
12384 PyThreadState* __tstate = wxPyBeginAllowThreads();
12385 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12386 wxPyEndAllowThreads(__tstate);
12387 if (PyErr_Occurred()) SWIG_fail;
12388 }
12389 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12390 return resultobj;
12391 fail:
12392 return NULL;
12393 }
12394
12395
12396 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12397 PyObject *resultobj = 0;
12398 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12399 byte *arg2 = (byte *) 0 ;
12400 byte *arg3 = (byte *) 0 ;
12401 byte *arg4 = (byte *) 0 ;
12402 byte arg5 = (byte) 1 ;
12403 byte arg6 = (byte) 0 ;
12404 byte arg7 = (byte) 0 ;
12405 bool result;
12406 void *argp1 = 0 ;
12407 int res1 = 0 ;
12408 byte temp2 ;
12409 int res2 = SWIG_TMPOBJ ;
12410 byte temp3 ;
12411 int res3 = SWIG_TMPOBJ ;
12412 byte temp4 ;
12413 int res4 = SWIG_TMPOBJ ;
12414 unsigned char val5 ;
12415 int ecode5 = 0 ;
12416 unsigned char val6 ;
12417 int ecode6 = 0 ;
12418 unsigned char val7 ;
12419 int ecode7 = 0 ;
12420 PyObject * obj0 = 0 ;
12421 PyObject * obj1 = 0 ;
12422 PyObject * obj2 = 0 ;
12423 PyObject * obj3 = 0 ;
12424 char * kwnames[] = {
12425 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12426 };
12427
12428 arg2 = &temp2;
12429 arg3 = &temp3;
12430 arg4 = &temp4;
12431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12433 if (!SWIG_IsOK(res1)) {
12434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12435 }
12436 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12437 if (obj1) {
12438 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12439 if (!SWIG_IsOK(ecode5)) {
12440 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12441 }
12442 arg5 = static_cast< byte >(val5);
12443 }
12444 if (obj2) {
12445 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12446 if (!SWIG_IsOK(ecode6)) {
12447 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12448 }
12449 arg6 = static_cast< byte >(val6);
12450 }
12451 if (obj3) {
12452 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12453 if (!SWIG_IsOK(ecode7)) {
12454 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12455 }
12456 arg7 = static_cast< byte >(val7);
12457 }
12458 {
12459 PyThreadState* __tstate = wxPyBeginAllowThreads();
12460 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12461 wxPyEndAllowThreads(__tstate);
12462 if (PyErr_Occurred()) SWIG_fail;
12463 }
12464 {
12465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12466 }
12467 if (SWIG_IsTmpObj(res2)) {
12468 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12469 } else {
12470 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12471 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12472 }
12473 if (SWIG_IsTmpObj(res3)) {
12474 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12475 } else {
12476 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12477 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12478 }
12479 if (SWIG_IsTmpObj(res4)) {
12480 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12481 } else {
12482 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12483 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12484 }
12485 return resultobj;
12486 fail:
12487 return NULL;
12488 }
12489
12490
12491 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12492 PyObject *resultobj = 0;
12493 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12494 unsigned long arg2 ;
12495 unsigned long result;
12496 void *argp1 = 0 ;
12497 int res1 = 0 ;
12498 unsigned long val2 ;
12499 int ecode2 = 0 ;
12500 PyObject * obj0 = 0 ;
12501 PyObject * obj1 = 0 ;
12502 char * kwnames[] = {
12503 (char *) "self",(char *) "key", NULL
12504 };
12505
12506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12508 if (!SWIG_IsOK(res1)) {
12509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12510 }
12511 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12512 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12513 if (!SWIG_IsOK(ecode2)) {
12514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12515 }
12516 arg2 = static_cast< unsigned long >(val2);
12517 {
12518 PyThreadState* __tstate = wxPyBeginAllowThreads();
12519 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12520 wxPyEndAllowThreads(__tstate);
12521 if (PyErr_Occurred()) SWIG_fail;
12522 }
12523 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12524 return resultobj;
12525 fail:
12526 return NULL;
12527 }
12528
12529
12530 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12531 PyObject *resultobj = 0;
12532 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12533 byte arg2 ;
12534 byte arg3 ;
12535 byte arg4 ;
12536 unsigned long result;
12537 void *argp1 = 0 ;
12538 int res1 = 0 ;
12539 unsigned char val2 ;
12540 int ecode2 = 0 ;
12541 unsigned char val3 ;
12542 int ecode3 = 0 ;
12543 unsigned char val4 ;
12544 int ecode4 = 0 ;
12545 PyObject * obj0 = 0 ;
12546 PyObject * obj1 = 0 ;
12547 PyObject * obj2 = 0 ;
12548 PyObject * obj3 = 0 ;
12549 char * kwnames[] = {
12550 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12551 };
12552
12553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12555 if (!SWIG_IsOK(res1)) {
12556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12557 }
12558 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12559 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12560 if (!SWIG_IsOK(ecode2)) {
12561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12562 }
12563 arg2 = static_cast< byte >(val2);
12564 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12565 if (!SWIG_IsOK(ecode3)) {
12566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12567 }
12568 arg3 = static_cast< byte >(val3);
12569 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12570 if (!SWIG_IsOK(ecode4)) {
12571 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12572 }
12573 arg4 = static_cast< byte >(val4);
12574 {
12575 PyThreadState* __tstate = wxPyBeginAllowThreads();
12576 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12577 wxPyEndAllowThreads(__tstate);
12578 if (PyErr_Occurred()) SWIG_fail;
12579 }
12580 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12581 return resultobj;
12582 fail:
12583 return NULL;
12584 }
12585
12586
12587 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12588 PyObject *resultobj = 0;
12589 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12590 wxColour *arg2 = 0 ;
12591 unsigned long result;
12592 void *argp1 = 0 ;
12593 int res1 = 0 ;
12594 wxColour temp2 ;
12595 PyObject * obj0 = 0 ;
12596 PyObject * obj1 = 0 ;
12597 char * kwnames[] = {
12598 (char *) "self",(char *) "colour", NULL
12599 };
12600
12601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12603 if (!SWIG_IsOK(res1)) {
12604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12605 }
12606 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12607 {
12608 arg2 = &temp2;
12609 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12610 }
12611 {
12612 PyThreadState* __tstate = wxPyBeginAllowThreads();
12613 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12614 wxPyEndAllowThreads(__tstate);
12615 if (PyErr_Occurred()) SWIG_fail;
12616 }
12617 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12618 return resultobj;
12619 fail:
12620 return NULL;
12621 }
12622
12623
12624 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12625 PyObject *obj;
12626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12627 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12628 return SWIG_Py_Void();
12629 }
12630
12631 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12632 return SWIG_Python_InitShadowInstance(args);
12633 }
12634
12635 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12636 PyObject *resultobj = 0;
12637 byte arg1 = (byte) 0 ;
12638 byte arg2 = (byte) 0 ;
12639 byte arg3 = (byte) 0 ;
12640 wxImage_RGBValue *result = 0 ;
12641 unsigned char val1 ;
12642 int ecode1 = 0 ;
12643 unsigned char val2 ;
12644 int ecode2 = 0 ;
12645 unsigned char val3 ;
12646 int ecode3 = 0 ;
12647 PyObject * obj0 = 0 ;
12648 PyObject * obj1 = 0 ;
12649 PyObject * obj2 = 0 ;
12650 char * kwnames[] = {
12651 (char *) "r",(char *) "g",(char *) "b", NULL
12652 };
12653
12654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12655 if (obj0) {
12656 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12657 if (!SWIG_IsOK(ecode1)) {
12658 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12659 }
12660 arg1 = static_cast< byte >(val1);
12661 }
12662 if (obj1) {
12663 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12664 if (!SWIG_IsOK(ecode2)) {
12665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12666 }
12667 arg2 = static_cast< byte >(val2);
12668 }
12669 if (obj2) {
12670 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12671 if (!SWIG_IsOK(ecode3)) {
12672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12673 }
12674 arg3 = static_cast< byte >(val3);
12675 }
12676 {
12677 PyThreadState* __tstate = wxPyBeginAllowThreads();
12678 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12679 wxPyEndAllowThreads(__tstate);
12680 if (PyErr_Occurred()) SWIG_fail;
12681 }
12682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12683 return resultobj;
12684 fail:
12685 return NULL;
12686 }
12687
12688
12689 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12690 PyObject *resultobj = 0;
12691 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12692 byte arg2 ;
12693 void *argp1 = 0 ;
12694 int res1 = 0 ;
12695 unsigned char val2 ;
12696 int ecode2 = 0 ;
12697 PyObject *swig_obj[2] ;
12698
12699 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12701 if (!SWIG_IsOK(res1)) {
12702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12703 }
12704 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12705 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12706 if (!SWIG_IsOK(ecode2)) {
12707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12708 }
12709 arg2 = static_cast< byte >(val2);
12710 if (arg1) (arg1)->red = arg2;
12711
12712 resultobj = SWIG_Py_Void();
12713 return resultobj;
12714 fail:
12715 return NULL;
12716 }
12717
12718
12719 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12720 PyObject *resultobj = 0;
12721 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12722 byte result;
12723 void *argp1 = 0 ;
12724 int res1 = 0 ;
12725 PyObject *swig_obj[1] ;
12726
12727 if (!args) SWIG_fail;
12728 swig_obj[0] = args;
12729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12730 if (!SWIG_IsOK(res1)) {
12731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12732 }
12733 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12734 result = (byte) ((arg1)->red);
12735 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12736 return resultobj;
12737 fail:
12738 return NULL;
12739 }
12740
12741
12742 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12743 PyObject *resultobj = 0;
12744 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12745 byte arg2 ;
12746 void *argp1 = 0 ;
12747 int res1 = 0 ;
12748 unsigned char val2 ;
12749 int ecode2 = 0 ;
12750 PyObject *swig_obj[2] ;
12751
12752 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12754 if (!SWIG_IsOK(res1)) {
12755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12756 }
12757 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12758 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12759 if (!SWIG_IsOK(ecode2)) {
12760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12761 }
12762 arg2 = static_cast< byte >(val2);
12763 if (arg1) (arg1)->green = arg2;
12764
12765 resultobj = SWIG_Py_Void();
12766 return resultobj;
12767 fail:
12768 return NULL;
12769 }
12770
12771
12772 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12773 PyObject *resultobj = 0;
12774 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12775 byte result;
12776 void *argp1 = 0 ;
12777 int res1 = 0 ;
12778 PyObject *swig_obj[1] ;
12779
12780 if (!args) SWIG_fail;
12781 swig_obj[0] = args;
12782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12783 if (!SWIG_IsOK(res1)) {
12784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12785 }
12786 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12787 result = (byte) ((arg1)->green);
12788 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12789 return resultobj;
12790 fail:
12791 return NULL;
12792 }
12793
12794
12795 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12796 PyObject *resultobj = 0;
12797 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12798 byte arg2 ;
12799 void *argp1 = 0 ;
12800 int res1 = 0 ;
12801 unsigned char val2 ;
12802 int ecode2 = 0 ;
12803 PyObject *swig_obj[2] ;
12804
12805 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12807 if (!SWIG_IsOK(res1)) {
12808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12809 }
12810 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12811 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12812 if (!SWIG_IsOK(ecode2)) {
12813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12814 }
12815 arg2 = static_cast< byte >(val2);
12816 if (arg1) (arg1)->blue = arg2;
12817
12818 resultobj = SWIG_Py_Void();
12819 return resultobj;
12820 fail:
12821 return NULL;
12822 }
12823
12824
12825 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12826 PyObject *resultobj = 0;
12827 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12828 byte result;
12829 void *argp1 = 0 ;
12830 int res1 = 0 ;
12831 PyObject *swig_obj[1] ;
12832
12833 if (!args) SWIG_fail;
12834 swig_obj[0] = args;
12835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12836 if (!SWIG_IsOK(res1)) {
12837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12838 }
12839 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12840 result = (byte) ((arg1)->blue);
12841 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12842 return resultobj;
12843 fail:
12844 return NULL;
12845 }
12846
12847
12848 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12849 PyObject *obj;
12850 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12851 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12852 return SWIG_Py_Void();
12853 }
12854
12855 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12856 return SWIG_Python_InitShadowInstance(args);
12857 }
12858
12859 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12860 PyObject *resultobj = 0;
12861 double arg1 = (double) 0.0 ;
12862 double arg2 = (double) 0.0 ;
12863 double arg3 = (double) 0.0 ;
12864 wxImage_HSVValue *result = 0 ;
12865 double val1 ;
12866 int ecode1 = 0 ;
12867 double val2 ;
12868 int ecode2 = 0 ;
12869 double val3 ;
12870 int ecode3 = 0 ;
12871 PyObject * obj0 = 0 ;
12872 PyObject * obj1 = 0 ;
12873 PyObject * obj2 = 0 ;
12874 char * kwnames[] = {
12875 (char *) "h",(char *) "s",(char *) "v", NULL
12876 };
12877
12878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12879 if (obj0) {
12880 ecode1 = SWIG_AsVal_double(obj0, &val1);
12881 if (!SWIG_IsOK(ecode1)) {
12882 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12883 }
12884 arg1 = static_cast< double >(val1);
12885 }
12886 if (obj1) {
12887 ecode2 = SWIG_AsVal_double(obj1, &val2);
12888 if (!SWIG_IsOK(ecode2)) {
12889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12890 }
12891 arg2 = static_cast< double >(val2);
12892 }
12893 if (obj2) {
12894 ecode3 = SWIG_AsVal_double(obj2, &val3);
12895 if (!SWIG_IsOK(ecode3)) {
12896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12897 }
12898 arg3 = static_cast< double >(val3);
12899 }
12900 {
12901 PyThreadState* __tstate = wxPyBeginAllowThreads();
12902 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12903 wxPyEndAllowThreads(__tstate);
12904 if (PyErr_Occurred()) SWIG_fail;
12905 }
12906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12907 return resultobj;
12908 fail:
12909 return NULL;
12910 }
12911
12912
12913 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12914 PyObject *resultobj = 0;
12915 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12916 double arg2 ;
12917 void *argp1 = 0 ;
12918 int res1 = 0 ;
12919 double val2 ;
12920 int ecode2 = 0 ;
12921 PyObject *swig_obj[2] ;
12922
12923 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12925 if (!SWIG_IsOK(res1)) {
12926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12927 }
12928 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12929 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12930 if (!SWIG_IsOK(ecode2)) {
12931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12932 }
12933 arg2 = static_cast< double >(val2);
12934 if (arg1) (arg1)->hue = arg2;
12935
12936 resultobj = SWIG_Py_Void();
12937 return resultobj;
12938 fail:
12939 return NULL;
12940 }
12941
12942
12943 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12944 PyObject *resultobj = 0;
12945 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12946 double result;
12947 void *argp1 = 0 ;
12948 int res1 = 0 ;
12949 PyObject *swig_obj[1] ;
12950
12951 if (!args) SWIG_fail;
12952 swig_obj[0] = args;
12953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12954 if (!SWIG_IsOK(res1)) {
12955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12956 }
12957 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12958 result = (double) ((arg1)->hue);
12959 resultobj = SWIG_From_double(static_cast< double >(result));
12960 return resultobj;
12961 fail:
12962 return NULL;
12963 }
12964
12965
12966 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12967 PyObject *resultobj = 0;
12968 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12969 double arg2 ;
12970 void *argp1 = 0 ;
12971 int res1 = 0 ;
12972 double val2 ;
12973 int ecode2 = 0 ;
12974 PyObject *swig_obj[2] ;
12975
12976 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12978 if (!SWIG_IsOK(res1)) {
12979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12980 }
12981 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12982 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12983 if (!SWIG_IsOK(ecode2)) {
12984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12985 }
12986 arg2 = static_cast< double >(val2);
12987 if (arg1) (arg1)->saturation = arg2;
12988
12989 resultobj = SWIG_Py_Void();
12990 return resultobj;
12991 fail:
12992 return NULL;
12993 }
12994
12995
12996 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12997 PyObject *resultobj = 0;
12998 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12999 double result;
13000 void *argp1 = 0 ;
13001 int res1 = 0 ;
13002 PyObject *swig_obj[1] ;
13003
13004 if (!args) SWIG_fail;
13005 swig_obj[0] = args;
13006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13007 if (!SWIG_IsOK(res1)) {
13008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13009 }
13010 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13011 result = (double) ((arg1)->saturation);
13012 resultobj = SWIG_From_double(static_cast< double >(result));
13013 return resultobj;
13014 fail:
13015 return NULL;
13016 }
13017
13018
13019 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13020 PyObject *resultobj = 0;
13021 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13022 double arg2 ;
13023 void *argp1 = 0 ;
13024 int res1 = 0 ;
13025 double val2 ;
13026 int ecode2 = 0 ;
13027 PyObject *swig_obj[2] ;
13028
13029 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
13030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13031 if (!SWIG_IsOK(res1)) {
13032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13033 }
13034 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13035 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
13036 if (!SWIG_IsOK(ecode2)) {
13037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
13038 }
13039 arg2 = static_cast< double >(val2);
13040 if (arg1) (arg1)->value = arg2;
13041
13042 resultobj = SWIG_Py_Void();
13043 return resultobj;
13044 fail:
13045 return NULL;
13046 }
13047
13048
13049 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13050 PyObject *resultobj = 0;
13051 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
13052 double result;
13053 void *argp1 = 0 ;
13054 int res1 = 0 ;
13055 PyObject *swig_obj[1] ;
13056
13057 if (!args) SWIG_fail;
13058 swig_obj[0] = args;
13059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
13060 if (!SWIG_IsOK(res1)) {
13061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
13062 }
13063 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
13064 result = (double) ((arg1)->value);
13065 resultobj = SWIG_From_double(static_cast< double >(result));
13066 return resultobj;
13067 fail:
13068 return NULL;
13069 }
13070
13071
13072 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13073 PyObject *obj;
13074 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13075 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
13076 return SWIG_Py_Void();
13077 }
13078
13079 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13080 return SWIG_Python_InitShadowInstance(args);
13081 }
13082
13083 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13084 PyObject *resultobj = 0;
13085 wxString *arg1 = 0 ;
13086 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13087 int arg3 = (int) -1 ;
13088 wxImage *result = 0 ;
13089 bool temp1 = false ;
13090 long val2 ;
13091 int ecode2 = 0 ;
13092 int val3 ;
13093 int ecode3 = 0 ;
13094 PyObject * obj0 = 0 ;
13095 PyObject * obj1 = 0 ;
13096 PyObject * obj2 = 0 ;
13097 char * kwnames[] = {
13098 (char *) "name",(char *) "type",(char *) "index", NULL
13099 };
13100
13101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13102 {
13103 arg1 = wxString_in_helper(obj0);
13104 if (arg1 == NULL) SWIG_fail;
13105 temp1 = true;
13106 }
13107 if (obj1) {
13108 ecode2 = SWIG_AsVal_long(obj1, &val2);
13109 if (!SWIG_IsOK(ecode2)) {
13110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
13111 }
13112 arg2 = static_cast< long >(val2);
13113 }
13114 if (obj2) {
13115 ecode3 = SWIG_AsVal_int(obj2, &val3);
13116 if (!SWIG_IsOK(ecode3)) {
13117 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13118 }
13119 arg3 = static_cast< int >(val3);
13120 }
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13124 wxPyEndAllowThreads(__tstate);
13125 if (PyErr_Occurred()) SWIG_fail;
13126 }
13127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13128 {
13129 if (temp1)
13130 delete arg1;
13131 }
13132 return resultobj;
13133 fail:
13134 {
13135 if (temp1)
13136 delete arg1;
13137 }
13138 return NULL;
13139 }
13140
13141
13142 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13143 PyObject *resultobj = 0;
13144 wxImage *arg1 = (wxImage *) 0 ;
13145 void *argp1 = 0 ;
13146 int res1 = 0 ;
13147 PyObject *swig_obj[1] ;
13148
13149 if (!args) SWIG_fail;
13150 swig_obj[0] = args;
13151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13152 if (!SWIG_IsOK(res1)) {
13153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13154 }
13155 arg1 = reinterpret_cast< wxImage * >(argp1);
13156 {
13157 PyThreadState* __tstate = wxPyBeginAllowThreads();
13158 delete arg1;
13159
13160 wxPyEndAllowThreads(__tstate);
13161 if (PyErr_Occurred()) SWIG_fail;
13162 }
13163 resultobj = SWIG_Py_Void();
13164 return resultobj;
13165 fail:
13166 return NULL;
13167 }
13168
13169
13170 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13171 PyObject *resultobj = 0;
13172 wxString *arg1 = 0 ;
13173 wxString *arg2 = 0 ;
13174 int arg3 = (int) -1 ;
13175 wxImage *result = 0 ;
13176 bool temp1 = false ;
13177 bool temp2 = false ;
13178 int val3 ;
13179 int ecode3 = 0 ;
13180 PyObject * obj0 = 0 ;
13181 PyObject * obj1 = 0 ;
13182 PyObject * obj2 = 0 ;
13183 char * kwnames[] = {
13184 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13185 };
13186
13187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13188 {
13189 arg1 = wxString_in_helper(obj0);
13190 if (arg1 == NULL) SWIG_fail;
13191 temp1 = true;
13192 }
13193 {
13194 arg2 = wxString_in_helper(obj1);
13195 if (arg2 == NULL) SWIG_fail;
13196 temp2 = true;
13197 }
13198 if (obj2) {
13199 ecode3 = SWIG_AsVal_int(obj2, &val3);
13200 if (!SWIG_IsOK(ecode3)) {
13201 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13202 }
13203 arg3 = static_cast< int >(val3);
13204 }
13205 {
13206 PyThreadState* __tstate = wxPyBeginAllowThreads();
13207 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13208 wxPyEndAllowThreads(__tstate);
13209 if (PyErr_Occurred()) SWIG_fail;
13210 }
13211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13212 {
13213 if (temp1)
13214 delete arg1;
13215 }
13216 {
13217 if (temp2)
13218 delete arg2;
13219 }
13220 return resultobj;
13221 fail:
13222 {
13223 if (temp1)
13224 delete arg1;
13225 }
13226 {
13227 if (temp2)
13228 delete arg2;
13229 }
13230 return NULL;
13231 }
13232
13233
13234 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13235 PyObject *resultobj = 0;
13236 wxInputStream *arg1 = 0 ;
13237 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13238 int arg3 = (int) -1 ;
13239 wxImage *result = 0 ;
13240 wxPyInputStream *temp1 ;
13241 bool created1 ;
13242 long val2 ;
13243 int ecode2 = 0 ;
13244 int val3 ;
13245 int ecode3 = 0 ;
13246 PyObject * obj0 = 0 ;
13247 PyObject * obj1 = 0 ;
13248 PyObject * obj2 = 0 ;
13249 char * kwnames[] = {
13250 (char *) "stream",(char *) "type",(char *) "index", NULL
13251 };
13252
13253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13254 {
13255 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13256 arg1 = temp1->m_wxis;
13257 created1 = false;
13258 } else {
13259 PyErr_Clear(); // clear the failure of the wxPyConvert above
13260 arg1 = wxPyCBInputStream_create(obj0, false);
13261 if (arg1 == NULL) {
13262 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13263 SWIG_fail;
13264 }
13265 created1 = true;
13266 }
13267 }
13268 if (obj1) {
13269 ecode2 = SWIG_AsVal_long(obj1, &val2);
13270 if (!SWIG_IsOK(ecode2)) {
13271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13272 }
13273 arg2 = static_cast< long >(val2);
13274 }
13275 if (obj2) {
13276 ecode3 = SWIG_AsVal_int(obj2, &val3);
13277 if (!SWIG_IsOK(ecode3)) {
13278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13279 }
13280 arg3 = static_cast< int >(val3);
13281 }
13282 {
13283 PyThreadState* __tstate = wxPyBeginAllowThreads();
13284 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13285 wxPyEndAllowThreads(__tstate);
13286 if (PyErr_Occurred()) SWIG_fail;
13287 }
13288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13289 {
13290 if (created1) delete arg1;
13291 }
13292 return resultobj;
13293 fail:
13294 {
13295 if (created1) delete arg1;
13296 }
13297 return NULL;
13298 }
13299
13300
13301 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13302 PyObject *resultobj = 0;
13303 wxInputStream *arg1 = 0 ;
13304 wxString *arg2 = 0 ;
13305 int arg3 = (int) -1 ;
13306 wxImage *result = 0 ;
13307 wxPyInputStream *temp1 ;
13308 bool created1 ;
13309 bool temp2 = false ;
13310 int val3 ;
13311 int ecode3 = 0 ;
13312 PyObject * obj0 = 0 ;
13313 PyObject * obj1 = 0 ;
13314 PyObject * obj2 = 0 ;
13315 char * kwnames[] = {
13316 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13317 };
13318
13319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13320 {
13321 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13322 arg1 = temp1->m_wxis;
13323 created1 = false;
13324 } else {
13325 PyErr_Clear(); // clear the failure of the wxPyConvert above
13326 arg1 = wxPyCBInputStream_create(obj0, false);
13327 if (arg1 == NULL) {
13328 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13329 SWIG_fail;
13330 }
13331 created1 = true;
13332 }
13333 }
13334 {
13335 arg2 = wxString_in_helper(obj1);
13336 if (arg2 == NULL) SWIG_fail;
13337 temp2 = true;
13338 }
13339 if (obj2) {
13340 ecode3 = SWIG_AsVal_int(obj2, &val3);
13341 if (!SWIG_IsOK(ecode3)) {
13342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13343 }
13344 arg3 = static_cast< int >(val3);
13345 }
13346 {
13347 PyThreadState* __tstate = wxPyBeginAllowThreads();
13348 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13349 wxPyEndAllowThreads(__tstate);
13350 if (PyErr_Occurred()) SWIG_fail;
13351 }
13352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13353 {
13354 if (created1) delete arg1;
13355 }
13356 {
13357 if (temp2)
13358 delete arg2;
13359 }
13360 return resultobj;
13361 fail:
13362 {
13363 if (created1) delete arg1;
13364 }
13365 {
13366 if (temp2)
13367 delete arg2;
13368 }
13369 return NULL;
13370 }
13371
13372
13373 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13374 PyObject *resultobj = 0;
13375 int arg1 = (int) 0 ;
13376 int arg2 = (int) 0 ;
13377 bool arg3 = (bool) true ;
13378 wxImage *result = 0 ;
13379 int val1 ;
13380 int ecode1 = 0 ;
13381 int val2 ;
13382 int ecode2 = 0 ;
13383 bool val3 ;
13384 int ecode3 = 0 ;
13385 PyObject * obj0 = 0 ;
13386 PyObject * obj1 = 0 ;
13387 PyObject * obj2 = 0 ;
13388 char * kwnames[] = {
13389 (char *) "width",(char *) "height",(char *) "clear", NULL
13390 };
13391
13392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13393 if (obj0) {
13394 ecode1 = SWIG_AsVal_int(obj0, &val1);
13395 if (!SWIG_IsOK(ecode1)) {
13396 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13397 }
13398 arg1 = static_cast< int >(val1);
13399 }
13400 if (obj1) {
13401 ecode2 = SWIG_AsVal_int(obj1, &val2);
13402 if (!SWIG_IsOK(ecode2)) {
13403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13404 }
13405 arg2 = static_cast< int >(val2);
13406 }
13407 if (obj2) {
13408 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13409 if (!SWIG_IsOK(ecode3)) {
13410 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13411 }
13412 arg3 = static_cast< bool >(val3);
13413 }
13414 {
13415 PyThreadState* __tstate = wxPyBeginAllowThreads();
13416 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13417 wxPyEndAllowThreads(__tstate);
13418 if (PyErr_Occurred()) SWIG_fail;
13419 }
13420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13421 return resultobj;
13422 fail:
13423 return NULL;
13424 }
13425
13426
13427 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13428 PyObject *resultobj = 0;
13429 wxBitmap *arg1 = 0 ;
13430 wxImage *result = 0 ;
13431 void *argp1 = 0 ;
13432 int res1 = 0 ;
13433 PyObject * obj0 = 0 ;
13434 char * kwnames[] = {
13435 (char *) "bitmap", NULL
13436 };
13437
13438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13439 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13440 if (!SWIG_IsOK(res1)) {
13441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13442 }
13443 if (!argp1) {
13444 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13445 }
13446 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13447 {
13448 if (!wxPyCheckForApp()) SWIG_fail;
13449 PyThreadState* __tstate = wxPyBeginAllowThreads();
13450 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13451 wxPyEndAllowThreads(__tstate);
13452 if (PyErr_Occurred()) SWIG_fail;
13453 }
13454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13455 return resultobj;
13456 fail:
13457 return NULL;
13458 }
13459
13460
13461 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13462 PyObject *resultobj = 0;
13463 int arg1 ;
13464 int arg2 ;
13465 buffer arg3 ;
13466 int arg4 ;
13467 wxImage *result = 0 ;
13468 int val1 ;
13469 int ecode1 = 0 ;
13470 int val2 ;
13471 int ecode2 = 0 ;
13472 Py_ssize_t temp3 ;
13473 PyObject * obj0 = 0 ;
13474 PyObject * obj1 = 0 ;
13475 PyObject * obj2 = 0 ;
13476 char * kwnames[] = {
13477 (char *) "width",(char *) "height",(char *) "data", NULL
13478 };
13479
13480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13481 ecode1 = SWIG_AsVal_int(obj0, &val1);
13482 if (!SWIG_IsOK(ecode1)) {
13483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13484 }
13485 arg1 = static_cast< int >(val1);
13486 ecode2 = SWIG_AsVal_int(obj1, &val2);
13487 if (!SWIG_IsOK(ecode2)) {
13488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13489 }
13490 arg2 = static_cast< int >(val2);
13491 {
13492 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13493 arg4 = (int)temp3;
13494 }
13495 {
13496 PyThreadState* __tstate = wxPyBeginAllowThreads();
13497 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13498 wxPyEndAllowThreads(__tstate);
13499 if (PyErr_Occurred()) SWIG_fail;
13500 }
13501 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13502 return resultobj;
13503 fail:
13504 return NULL;
13505 }
13506
13507
13508 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13509 PyObject *resultobj = 0;
13510 int arg1 ;
13511 int arg2 ;
13512 buffer arg3 ;
13513 int arg4 ;
13514 buffer arg5 ;
13515 int arg6 ;
13516 wxImage *result = 0 ;
13517 int val1 ;
13518 int ecode1 = 0 ;
13519 int val2 ;
13520 int ecode2 = 0 ;
13521 Py_ssize_t temp3 ;
13522 Py_ssize_t temp5 ;
13523 PyObject * obj0 = 0 ;
13524 PyObject * obj1 = 0 ;
13525 PyObject * obj2 = 0 ;
13526 PyObject * obj3 = 0 ;
13527 char * kwnames[] = {
13528 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13529 };
13530
13531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13532 ecode1 = SWIG_AsVal_int(obj0, &val1);
13533 if (!SWIG_IsOK(ecode1)) {
13534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13535 }
13536 arg1 = static_cast< int >(val1);
13537 ecode2 = SWIG_AsVal_int(obj1, &val2);
13538 if (!SWIG_IsOK(ecode2)) {
13539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13540 }
13541 arg2 = static_cast< int >(val2);
13542 {
13543 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
13544 arg4 = (int)temp3;
13545 }
13546 {
13547 if (obj3 != Py_None) {
13548 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
13549 arg6 = (int)temp5;
13550 }
13551 }
13552 {
13553 PyThreadState* __tstate = wxPyBeginAllowThreads();
13554 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13555 wxPyEndAllowThreads(__tstate);
13556 if (PyErr_Occurred()) SWIG_fail;
13557 }
13558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13559 return resultobj;
13560 fail:
13561 return NULL;
13562 }
13563
13564
13565 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13566 PyObject *resultobj = 0;
13567 wxImage *arg1 = (wxImage *) 0 ;
13568 int arg2 ;
13569 int arg3 ;
13570 bool arg4 = (bool) true ;
13571 void *argp1 = 0 ;
13572 int res1 = 0 ;
13573 int val2 ;
13574 int ecode2 = 0 ;
13575 int val3 ;
13576 int ecode3 = 0 ;
13577 bool val4 ;
13578 int ecode4 = 0 ;
13579 PyObject * obj0 = 0 ;
13580 PyObject * obj1 = 0 ;
13581 PyObject * obj2 = 0 ;
13582 PyObject * obj3 = 0 ;
13583 char * kwnames[] = {
13584 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13585 };
13586
13587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13589 if (!SWIG_IsOK(res1)) {
13590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13591 }
13592 arg1 = reinterpret_cast< wxImage * >(argp1);
13593 ecode2 = SWIG_AsVal_int(obj1, &val2);
13594 if (!SWIG_IsOK(ecode2)) {
13595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13596 }
13597 arg2 = static_cast< int >(val2);
13598 ecode3 = SWIG_AsVal_int(obj2, &val3);
13599 if (!SWIG_IsOK(ecode3)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13601 }
13602 arg3 = static_cast< int >(val3);
13603 if (obj3) {
13604 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13605 if (!SWIG_IsOK(ecode4)) {
13606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13607 }
13608 arg4 = static_cast< bool >(val4);
13609 }
13610 {
13611 PyThreadState* __tstate = wxPyBeginAllowThreads();
13612 (arg1)->Create(arg2,arg3,arg4);
13613 wxPyEndAllowThreads(__tstate);
13614 if (PyErr_Occurred()) SWIG_fail;
13615 }
13616 resultobj = SWIG_Py_Void();
13617 return resultobj;
13618 fail:
13619 return NULL;
13620 }
13621
13622
13623 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13624 PyObject *resultobj = 0;
13625 wxImage *arg1 = (wxImage *) 0 ;
13626 void *argp1 = 0 ;
13627 int res1 = 0 ;
13628 PyObject *swig_obj[1] ;
13629
13630 if (!args) SWIG_fail;
13631 swig_obj[0] = args;
13632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13633 if (!SWIG_IsOK(res1)) {
13634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13635 }
13636 arg1 = reinterpret_cast< wxImage * >(argp1);
13637 {
13638 PyThreadState* __tstate = wxPyBeginAllowThreads();
13639 (arg1)->Destroy();
13640 wxPyEndAllowThreads(__tstate);
13641 if (PyErr_Occurred()) SWIG_fail;
13642 }
13643 resultobj = SWIG_Py_Void();
13644 return resultobj;
13645 fail:
13646 return NULL;
13647 }
13648
13649
13650 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13651 PyObject *resultobj = 0;
13652 wxImage *arg1 = (wxImage *) 0 ;
13653 int arg2 ;
13654 int arg3 ;
13655 SwigValueWrapper<wxImage > result;
13656 void *argp1 = 0 ;
13657 int res1 = 0 ;
13658 int val2 ;
13659 int ecode2 = 0 ;
13660 int val3 ;
13661 int ecode3 = 0 ;
13662 PyObject * obj0 = 0 ;
13663 PyObject * obj1 = 0 ;
13664 PyObject * obj2 = 0 ;
13665 char * kwnames[] = {
13666 (char *) "self",(char *) "width",(char *) "height", NULL
13667 };
13668
13669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13671 if (!SWIG_IsOK(res1)) {
13672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13673 }
13674 arg1 = reinterpret_cast< wxImage * >(argp1);
13675 ecode2 = SWIG_AsVal_int(obj1, &val2);
13676 if (!SWIG_IsOK(ecode2)) {
13677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13678 }
13679 arg2 = static_cast< int >(val2);
13680 ecode3 = SWIG_AsVal_int(obj2, &val3);
13681 if (!SWIG_IsOK(ecode3)) {
13682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13683 }
13684 arg3 = static_cast< int >(val3);
13685 {
13686 PyThreadState* __tstate = wxPyBeginAllowThreads();
13687 result = (arg1)->Scale(arg2,arg3);
13688 wxPyEndAllowThreads(__tstate);
13689 if (PyErr_Occurred()) SWIG_fail;
13690 }
13691 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13692 return resultobj;
13693 fail:
13694 return NULL;
13695 }
13696
13697
13698 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13699 PyObject *resultobj = 0;
13700 wxImage *arg1 = (wxImage *) 0 ;
13701 int arg2 ;
13702 int arg3 ;
13703 SwigValueWrapper<wxImage > result;
13704 void *argp1 = 0 ;
13705 int res1 = 0 ;
13706 int val2 ;
13707 int ecode2 = 0 ;
13708 int val3 ;
13709 int ecode3 = 0 ;
13710 PyObject * obj0 = 0 ;
13711 PyObject * obj1 = 0 ;
13712 PyObject * obj2 = 0 ;
13713 char * kwnames[] = {
13714 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13715 };
13716
13717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13719 if (!SWIG_IsOK(res1)) {
13720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13721 }
13722 arg1 = reinterpret_cast< wxImage * >(argp1);
13723 ecode2 = SWIG_AsVal_int(obj1, &val2);
13724 if (!SWIG_IsOK(ecode2)) {
13725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13726 }
13727 arg2 = static_cast< int >(val2);
13728 ecode3 = SWIG_AsVal_int(obj2, &val3);
13729 if (!SWIG_IsOK(ecode3)) {
13730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13731 }
13732 arg3 = static_cast< int >(val3);
13733 {
13734 PyThreadState* __tstate = wxPyBeginAllowThreads();
13735 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13736 wxPyEndAllowThreads(__tstate);
13737 if (PyErr_Occurred()) SWIG_fail;
13738 }
13739 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13740 return resultobj;
13741 fail:
13742 return NULL;
13743 }
13744
13745
13746 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13747 PyObject *resultobj = 0;
13748 wxImage *arg1 = (wxImage *) 0 ;
13749 int arg2 ;
13750 int arg3 ;
13751 wxImage *result = 0 ;
13752 void *argp1 = 0 ;
13753 int res1 = 0 ;
13754 int val2 ;
13755 int ecode2 = 0 ;
13756 int val3 ;
13757 int ecode3 = 0 ;
13758 PyObject * obj0 = 0 ;
13759 PyObject * obj1 = 0 ;
13760 PyObject * obj2 = 0 ;
13761 char * kwnames[] = {
13762 (char *) "self",(char *) "width",(char *) "height", NULL
13763 };
13764
13765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13767 if (!SWIG_IsOK(res1)) {
13768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13769 }
13770 arg1 = reinterpret_cast< wxImage * >(argp1);
13771 ecode2 = SWIG_AsVal_int(obj1, &val2);
13772 if (!SWIG_IsOK(ecode2)) {
13773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13774 }
13775 arg2 = static_cast< int >(val2);
13776 ecode3 = SWIG_AsVal_int(obj2, &val3);
13777 if (!SWIG_IsOK(ecode3)) {
13778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13779 }
13780 arg3 = static_cast< int >(val3);
13781 {
13782 PyThreadState* __tstate = wxPyBeginAllowThreads();
13783 {
13784 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13785 result = (wxImage *) &_result_ref;
13786 }
13787 wxPyEndAllowThreads(__tstate);
13788 if (PyErr_Occurred()) SWIG_fail;
13789 }
13790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13791 return resultobj;
13792 fail:
13793 return NULL;
13794 }
13795
13796
13797 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13798 PyObject *resultobj = 0;
13799 wxImage *arg1 = (wxImage *) 0 ;
13800 wxSize *arg2 = 0 ;
13801 wxPoint *arg3 = 0 ;
13802 int arg4 = (int) -1 ;
13803 int arg5 = (int) -1 ;
13804 int arg6 = (int) -1 ;
13805 wxImage *result = 0 ;
13806 void *argp1 = 0 ;
13807 int res1 = 0 ;
13808 wxSize temp2 ;
13809 wxPoint temp3 ;
13810 int val4 ;
13811 int ecode4 = 0 ;
13812 int val5 ;
13813 int ecode5 = 0 ;
13814 int val6 ;
13815 int ecode6 = 0 ;
13816 PyObject * obj0 = 0 ;
13817 PyObject * obj1 = 0 ;
13818 PyObject * obj2 = 0 ;
13819 PyObject * obj3 = 0 ;
13820 PyObject * obj4 = 0 ;
13821 PyObject * obj5 = 0 ;
13822 char * kwnames[] = {
13823 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13824 };
13825
13826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13828 if (!SWIG_IsOK(res1)) {
13829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13830 }
13831 arg1 = reinterpret_cast< wxImage * >(argp1);
13832 {
13833 arg2 = &temp2;
13834 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13835 }
13836 {
13837 arg3 = &temp3;
13838 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13839 }
13840 if (obj3) {
13841 ecode4 = SWIG_AsVal_int(obj3, &val4);
13842 if (!SWIG_IsOK(ecode4)) {
13843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13844 }
13845 arg4 = static_cast< int >(val4);
13846 }
13847 if (obj4) {
13848 ecode5 = SWIG_AsVal_int(obj4, &val5);
13849 if (!SWIG_IsOK(ecode5)) {
13850 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13851 }
13852 arg5 = static_cast< int >(val5);
13853 }
13854 if (obj5) {
13855 ecode6 = SWIG_AsVal_int(obj5, &val6);
13856 if (!SWIG_IsOK(ecode6)) {
13857 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13858 }
13859 arg6 = static_cast< int >(val6);
13860 }
13861 {
13862 PyThreadState* __tstate = wxPyBeginAllowThreads();
13863 {
13864 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13865 result = (wxImage *) &_result_ref;
13866 }
13867 wxPyEndAllowThreads(__tstate);
13868 if (PyErr_Occurred()) SWIG_fail;
13869 }
13870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13871 return resultobj;
13872 fail:
13873 return NULL;
13874 }
13875
13876
13877 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13878 PyObject *resultobj = 0;
13879 wxImage *arg1 = (wxImage *) 0 ;
13880 int arg2 ;
13881 int arg3 ;
13882 byte arg4 ;
13883 byte arg5 ;
13884 byte arg6 ;
13885 void *argp1 = 0 ;
13886 int res1 = 0 ;
13887 int val2 ;
13888 int ecode2 = 0 ;
13889 int val3 ;
13890 int ecode3 = 0 ;
13891 unsigned char val4 ;
13892 int ecode4 = 0 ;
13893 unsigned char val5 ;
13894 int ecode5 = 0 ;
13895 unsigned char val6 ;
13896 int ecode6 = 0 ;
13897 PyObject * obj0 = 0 ;
13898 PyObject * obj1 = 0 ;
13899 PyObject * obj2 = 0 ;
13900 PyObject * obj3 = 0 ;
13901 PyObject * obj4 = 0 ;
13902 PyObject * obj5 = 0 ;
13903 char * kwnames[] = {
13904 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13905 };
13906
13907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13909 if (!SWIG_IsOK(res1)) {
13910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13911 }
13912 arg1 = reinterpret_cast< wxImage * >(argp1);
13913 ecode2 = SWIG_AsVal_int(obj1, &val2);
13914 if (!SWIG_IsOK(ecode2)) {
13915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13916 }
13917 arg2 = static_cast< int >(val2);
13918 ecode3 = SWIG_AsVal_int(obj2, &val3);
13919 if (!SWIG_IsOK(ecode3)) {
13920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13921 }
13922 arg3 = static_cast< int >(val3);
13923 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13924 if (!SWIG_IsOK(ecode4)) {
13925 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13926 }
13927 arg4 = static_cast< byte >(val4);
13928 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13929 if (!SWIG_IsOK(ecode5)) {
13930 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13931 }
13932 arg5 = static_cast< byte >(val5);
13933 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13934 if (!SWIG_IsOK(ecode6)) {
13935 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13936 }
13937 arg6 = static_cast< byte >(val6);
13938 {
13939 PyThreadState* __tstate = wxPyBeginAllowThreads();
13940 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13941 wxPyEndAllowThreads(__tstate);
13942 if (PyErr_Occurred()) SWIG_fail;
13943 }
13944 resultobj = SWIG_Py_Void();
13945 return resultobj;
13946 fail:
13947 return NULL;
13948 }
13949
13950
13951 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13952 PyObject *resultobj = 0;
13953 wxImage *arg1 = (wxImage *) 0 ;
13954 wxRect *arg2 = 0 ;
13955 byte arg3 ;
13956 byte arg4 ;
13957 byte arg5 ;
13958 void *argp1 = 0 ;
13959 int res1 = 0 ;
13960 wxRect temp2 ;
13961 unsigned char val3 ;
13962 int ecode3 = 0 ;
13963 unsigned char val4 ;
13964 int ecode4 = 0 ;
13965 unsigned char val5 ;
13966 int ecode5 = 0 ;
13967 PyObject * obj0 = 0 ;
13968 PyObject * obj1 = 0 ;
13969 PyObject * obj2 = 0 ;
13970 PyObject * obj3 = 0 ;
13971 PyObject * obj4 = 0 ;
13972 char * kwnames[] = {
13973 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13974 };
13975
13976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13978 if (!SWIG_IsOK(res1)) {
13979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13980 }
13981 arg1 = reinterpret_cast< wxImage * >(argp1);
13982 {
13983 arg2 = &temp2;
13984 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13985 }
13986 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13987 if (!SWIG_IsOK(ecode3)) {
13988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13989 }
13990 arg3 = static_cast< byte >(val3);
13991 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13992 if (!SWIG_IsOK(ecode4)) {
13993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13994 }
13995 arg4 = static_cast< byte >(val4);
13996 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13997 if (!SWIG_IsOK(ecode5)) {
13998 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13999 }
14000 arg5 = static_cast< byte >(val5);
14001 {
14002 PyThreadState* __tstate = wxPyBeginAllowThreads();
14003 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
14004 wxPyEndAllowThreads(__tstate);
14005 if (PyErr_Occurred()) SWIG_fail;
14006 }
14007 resultobj = SWIG_Py_Void();
14008 return resultobj;
14009 fail:
14010 return NULL;
14011 }
14012
14013
14014 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14015 PyObject *resultobj = 0;
14016 wxImage *arg1 = (wxImage *) 0 ;
14017 int arg2 ;
14018 int arg3 ;
14019 byte result;
14020 void *argp1 = 0 ;
14021 int res1 = 0 ;
14022 int val2 ;
14023 int ecode2 = 0 ;
14024 int val3 ;
14025 int ecode3 = 0 ;
14026 PyObject * obj0 = 0 ;
14027 PyObject * obj1 = 0 ;
14028 PyObject * obj2 = 0 ;
14029 char * kwnames[] = {
14030 (char *) "self",(char *) "x",(char *) "y", NULL
14031 };
14032
14033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14035 if (!SWIG_IsOK(res1)) {
14036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
14037 }
14038 arg1 = reinterpret_cast< wxImage * >(argp1);
14039 ecode2 = SWIG_AsVal_int(obj1, &val2);
14040 if (!SWIG_IsOK(ecode2)) {
14041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
14042 }
14043 arg2 = static_cast< int >(val2);
14044 ecode3 = SWIG_AsVal_int(obj2, &val3);
14045 if (!SWIG_IsOK(ecode3)) {
14046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
14047 }
14048 arg3 = static_cast< int >(val3);
14049 {
14050 PyThreadState* __tstate = wxPyBeginAllowThreads();
14051 result = (byte)(arg1)->GetRed(arg2,arg3);
14052 wxPyEndAllowThreads(__tstate);
14053 if (PyErr_Occurred()) SWIG_fail;
14054 }
14055 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14056 return resultobj;
14057 fail:
14058 return NULL;
14059 }
14060
14061
14062 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14063 PyObject *resultobj = 0;
14064 wxImage *arg1 = (wxImage *) 0 ;
14065 int arg2 ;
14066 int arg3 ;
14067 byte result;
14068 void *argp1 = 0 ;
14069 int res1 = 0 ;
14070 int val2 ;
14071 int ecode2 = 0 ;
14072 int val3 ;
14073 int ecode3 = 0 ;
14074 PyObject * obj0 = 0 ;
14075 PyObject * obj1 = 0 ;
14076 PyObject * obj2 = 0 ;
14077 char * kwnames[] = {
14078 (char *) "self",(char *) "x",(char *) "y", NULL
14079 };
14080
14081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14083 if (!SWIG_IsOK(res1)) {
14084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
14085 }
14086 arg1 = reinterpret_cast< wxImage * >(argp1);
14087 ecode2 = SWIG_AsVal_int(obj1, &val2);
14088 if (!SWIG_IsOK(ecode2)) {
14089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
14090 }
14091 arg2 = static_cast< int >(val2);
14092 ecode3 = SWIG_AsVal_int(obj2, &val3);
14093 if (!SWIG_IsOK(ecode3)) {
14094 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
14095 }
14096 arg3 = static_cast< int >(val3);
14097 {
14098 PyThreadState* __tstate = wxPyBeginAllowThreads();
14099 result = (byte)(arg1)->GetGreen(arg2,arg3);
14100 wxPyEndAllowThreads(__tstate);
14101 if (PyErr_Occurred()) SWIG_fail;
14102 }
14103 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14104 return resultobj;
14105 fail:
14106 return NULL;
14107 }
14108
14109
14110 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14111 PyObject *resultobj = 0;
14112 wxImage *arg1 = (wxImage *) 0 ;
14113 int arg2 ;
14114 int arg3 ;
14115 byte result;
14116 void *argp1 = 0 ;
14117 int res1 = 0 ;
14118 int val2 ;
14119 int ecode2 = 0 ;
14120 int val3 ;
14121 int ecode3 = 0 ;
14122 PyObject * obj0 = 0 ;
14123 PyObject * obj1 = 0 ;
14124 PyObject * obj2 = 0 ;
14125 char * kwnames[] = {
14126 (char *) "self",(char *) "x",(char *) "y", NULL
14127 };
14128
14129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14131 if (!SWIG_IsOK(res1)) {
14132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14133 }
14134 arg1 = reinterpret_cast< wxImage * >(argp1);
14135 ecode2 = SWIG_AsVal_int(obj1, &val2);
14136 if (!SWIG_IsOK(ecode2)) {
14137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14138 }
14139 arg2 = static_cast< int >(val2);
14140 ecode3 = SWIG_AsVal_int(obj2, &val3);
14141 if (!SWIG_IsOK(ecode3)) {
14142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14143 }
14144 arg3 = static_cast< int >(val3);
14145 {
14146 PyThreadState* __tstate = wxPyBeginAllowThreads();
14147 result = (byte)(arg1)->GetBlue(arg2,arg3);
14148 wxPyEndAllowThreads(__tstate);
14149 if (PyErr_Occurred()) SWIG_fail;
14150 }
14151 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14152 return resultobj;
14153 fail:
14154 return NULL;
14155 }
14156
14157
14158 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14159 PyObject *resultobj = 0;
14160 wxImage *arg1 = (wxImage *) 0 ;
14161 int arg2 ;
14162 int arg3 ;
14163 byte arg4 ;
14164 void *argp1 = 0 ;
14165 int res1 = 0 ;
14166 int val2 ;
14167 int ecode2 = 0 ;
14168 int val3 ;
14169 int ecode3 = 0 ;
14170 unsigned char val4 ;
14171 int ecode4 = 0 ;
14172 PyObject * obj0 = 0 ;
14173 PyObject * obj1 = 0 ;
14174 PyObject * obj2 = 0 ;
14175 PyObject * obj3 = 0 ;
14176 char * kwnames[] = {
14177 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14178 };
14179
14180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14182 if (!SWIG_IsOK(res1)) {
14183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14184 }
14185 arg1 = reinterpret_cast< wxImage * >(argp1);
14186 ecode2 = SWIG_AsVal_int(obj1, &val2);
14187 if (!SWIG_IsOK(ecode2)) {
14188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14189 }
14190 arg2 = static_cast< int >(val2);
14191 ecode3 = SWIG_AsVal_int(obj2, &val3);
14192 if (!SWIG_IsOK(ecode3)) {
14193 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14194 }
14195 arg3 = static_cast< int >(val3);
14196 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14197 if (!SWIG_IsOK(ecode4)) {
14198 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14199 }
14200 arg4 = static_cast< byte >(val4);
14201 {
14202 PyThreadState* __tstate = wxPyBeginAllowThreads();
14203 (arg1)->SetAlpha(arg2,arg3,arg4);
14204 wxPyEndAllowThreads(__tstate);
14205 if (PyErr_Occurred()) SWIG_fail;
14206 }
14207 resultobj = SWIG_Py_Void();
14208 return resultobj;
14209 fail:
14210 return NULL;
14211 }
14212
14213
14214 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14215 PyObject *resultobj = 0;
14216 wxImage *arg1 = (wxImage *) 0 ;
14217 int arg2 ;
14218 int arg3 ;
14219 byte result;
14220 void *argp1 = 0 ;
14221 int res1 = 0 ;
14222 int val2 ;
14223 int ecode2 = 0 ;
14224 int val3 ;
14225 int ecode3 = 0 ;
14226 PyObject * obj0 = 0 ;
14227 PyObject * obj1 = 0 ;
14228 PyObject * obj2 = 0 ;
14229 char * kwnames[] = {
14230 (char *) "self",(char *) "x",(char *) "y", NULL
14231 };
14232
14233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14235 if (!SWIG_IsOK(res1)) {
14236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14237 }
14238 arg1 = reinterpret_cast< wxImage * >(argp1);
14239 ecode2 = SWIG_AsVal_int(obj1, &val2);
14240 if (!SWIG_IsOK(ecode2)) {
14241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14242 }
14243 arg2 = static_cast< int >(val2);
14244 ecode3 = SWIG_AsVal_int(obj2, &val3);
14245 if (!SWIG_IsOK(ecode3)) {
14246 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14247 }
14248 arg3 = static_cast< int >(val3);
14249 {
14250 PyThreadState* __tstate = wxPyBeginAllowThreads();
14251 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14252 wxPyEndAllowThreads(__tstate);
14253 if (PyErr_Occurred()) SWIG_fail;
14254 }
14255 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14256 return resultobj;
14257 fail:
14258 return NULL;
14259 }
14260
14261
14262 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14263 PyObject *resultobj = 0;
14264 wxImage *arg1 = (wxImage *) 0 ;
14265 bool result;
14266 void *argp1 = 0 ;
14267 int res1 = 0 ;
14268 PyObject *swig_obj[1] ;
14269
14270 if (!args) SWIG_fail;
14271 swig_obj[0] = args;
14272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14273 if (!SWIG_IsOK(res1)) {
14274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14275 }
14276 arg1 = reinterpret_cast< wxImage * >(argp1);
14277 {
14278 PyThreadState* __tstate = wxPyBeginAllowThreads();
14279 result = (bool)(arg1)->HasAlpha();
14280 wxPyEndAllowThreads(__tstate);
14281 if (PyErr_Occurred()) SWIG_fail;
14282 }
14283 {
14284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14285 }
14286 return resultobj;
14287 fail:
14288 return NULL;
14289 }
14290
14291
14292 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14293 PyObject *resultobj = 0;
14294 wxImage *arg1 = (wxImage *) 0 ;
14295 void *argp1 = 0 ;
14296 int res1 = 0 ;
14297 PyObject *swig_obj[1] ;
14298
14299 if (!args) SWIG_fail;
14300 swig_obj[0] = args;
14301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14302 if (!SWIG_IsOK(res1)) {
14303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14304 }
14305 arg1 = reinterpret_cast< wxImage * >(argp1);
14306 {
14307 PyThreadState* __tstate = wxPyBeginAllowThreads();
14308 (arg1)->InitAlpha();
14309 wxPyEndAllowThreads(__tstate);
14310 if (PyErr_Occurred()) SWIG_fail;
14311 }
14312 resultobj = SWIG_Py_Void();
14313 return resultobj;
14314 fail:
14315 return NULL;
14316 }
14317
14318
14319 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14320 PyObject *resultobj = 0;
14321 wxImage *arg1 = (wxImage *) 0 ;
14322 int arg2 ;
14323 int arg3 ;
14324 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14325 bool result;
14326 void *argp1 = 0 ;
14327 int res1 = 0 ;
14328 int val2 ;
14329 int ecode2 = 0 ;
14330 int val3 ;
14331 int ecode3 = 0 ;
14332 unsigned char val4 ;
14333 int ecode4 = 0 ;
14334 PyObject * obj0 = 0 ;
14335 PyObject * obj1 = 0 ;
14336 PyObject * obj2 = 0 ;
14337 PyObject * obj3 = 0 ;
14338 char * kwnames[] = {
14339 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14340 };
14341
14342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14344 if (!SWIG_IsOK(res1)) {
14345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14346 }
14347 arg1 = reinterpret_cast< wxImage * >(argp1);
14348 ecode2 = SWIG_AsVal_int(obj1, &val2);
14349 if (!SWIG_IsOK(ecode2)) {
14350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14351 }
14352 arg2 = static_cast< int >(val2);
14353 ecode3 = SWIG_AsVal_int(obj2, &val3);
14354 if (!SWIG_IsOK(ecode3)) {
14355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14356 }
14357 arg3 = static_cast< int >(val3);
14358 if (obj3) {
14359 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14360 if (!SWIG_IsOK(ecode4)) {
14361 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14362 }
14363 arg4 = static_cast< byte >(val4);
14364 }
14365 {
14366 PyThreadState* __tstate = wxPyBeginAllowThreads();
14367 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14368 wxPyEndAllowThreads(__tstate);
14369 if (PyErr_Occurred()) SWIG_fail;
14370 }
14371 {
14372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14373 }
14374 return resultobj;
14375 fail:
14376 return NULL;
14377 }
14378
14379
14380 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14381 PyObject *resultobj = 0;
14382 wxImage *arg1 = (wxImage *) 0 ;
14383 byte *arg2 = (byte *) 0 ;
14384 byte *arg3 = (byte *) 0 ;
14385 byte *arg4 = (byte *) 0 ;
14386 byte arg5 = (byte) 0 ;
14387 byte arg6 = (byte) 0 ;
14388 byte arg7 = (byte) 0 ;
14389 bool result;
14390 void *argp1 = 0 ;
14391 int res1 = 0 ;
14392 byte temp2 ;
14393 int res2 = SWIG_TMPOBJ ;
14394 byte temp3 ;
14395 int res3 = SWIG_TMPOBJ ;
14396 byte temp4 ;
14397 int res4 = SWIG_TMPOBJ ;
14398 unsigned char val5 ;
14399 int ecode5 = 0 ;
14400 unsigned char val6 ;
14401 int ecode6 = 0 ;
14402 unsigned char val7 ;
14403 int ecode7 = 0 ;
14404 PyObject * obj0 = 0 ;
14405 PyObject * obj1 = 0 ;
14406 PyObject * obj2 = 0 ;
14407 PyObject * obj3 = 0 ;
14408 char * kwnames[] = {
14409 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14410 };
14411
14412 arg2 = &temp2;
14413 arg3 = &temp3;
14414 arg4 = &temp4;
14415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14417 if (!SWIG_IsOK(res1)) {
14418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14419 }
14420 arg1 = reinterpret_cast< wxImage * >(argp1);
14421 if (obj1) {
14422 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14423 if (!SWIG_IsOK(ecode5)) {
14424 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14425 }
14426 arg5 = static_cast< byte >(val5);
14427 }
14428 if (obj2) {
14429 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14430 if (!SWIG_IsOK(ecode6)) {
14431 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14432 }
14433 arg6 = static_cast< byte >(val6);
14434 }
14435 if (obj3) {
14436 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14437 if (!SWIG_IsOK(ecode7)) {
14438 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14439 }
14440 arg7 = static_cast< byte >(val7);
14441 }
14442 {
14443 PyThreadState* __tstate = wxPyBeginAllowThreads();
14444 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14445 wxPyEndAllowThreads(__tstate);
14446 if (PyErr_Occurred()) SWIG_fail;
14447 }
14448 {
14449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14450 }
14451 if (SWIG_IsTmpObj(res2)) {
14452 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14453 } else {
14454 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14456 }
14457 if (SWIG_IsTmpObj(res3)) {
14458 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14459 } else {
14460 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14462 }
14463 if (SWIG_IsTmpObj(res4)) {
14464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14465 } else {
14466 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14468 }
14469 return resultobj;
14470 fail:
14471 return NULL;
14472 }
14473
14474
14475 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14476 PyObject *resultobj = 0;
14477 wxImage *arg1 = (wxImage *) 0 ;
14478 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14479 bool result;
14480 void *argp1 = 0 ;
14481 int res1 = 0 ;
14482 unsigned char val2 ;
14483 int ecode2 = 0 ;
14484 PyObject * obj0 = 0 ;
14485 PyObject * obj1 = 0 ;
14486 char * kwnames[] = {
14487 (char *) "self",(char *) "threshold", NULL
14488 };
14489
14490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14492 if (!SWIG_IsOK(res1)) {
14493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14494 }
14495 arg1 = reinterpret_cast< wxImage * >(argp1);
14496 if (obj1) {
14497 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14498 if (!SWIG_IsOK(ecode2)) {
14499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14500 }
14501 arg2 = static_cast< byte >(val2);
14502 }
14503 {
14504 PyThreadState* __tstate = wxPyBeginAllowThreads();
14505 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14506 wxPyEndAllowThreads(__tstate);
14507 if (PyErr_Occurred()) SWIG_fail;
14508 }
14509 {
14510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14511 }
14512 return resultobj;
14513 fail:
14514 return NULL;
14515 }
14516
14517
14518 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14519 PyObject *resultobj = 0;
14520 wxImage *arg1 = (wxImage *) 0 ;
14521 byte arg2 ;
14522 byte arg3 ;
14523 byte arg4 ;
14524 bool result;
14525 void *argp1 = 0 ;
14526 int res1 = 0 ;
14527 unsigned char val2 ;
14528 int ecode2 = 0 ;
14529 unsigned char val3 ;
14530 int ecode3 = 0 ;
14531 unsigned char val4 ;
14532 int ecode4 = 0 ;
14533 PyObject * obj0 = 0 ;
14534 PyObject * obj1 = 0 ;
14535 PyObject * obj2 = 0 ;
14536 PyObject * obj3 = 0 ;
14537 char * kwnames[] = {
14538 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14539 };
14540
14541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14543 if (!SWIG_IsOK(res1)) {
14544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14545 }
14546 arg1 = reinterpret_cast< wxImage * >(argp1);
14547 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14548 if (!SWIG_IsOK(ecode2)) {
14549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14550 }
14551 arg2 = static_cast< byte >(val2);
14552 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14553 if (!SWIG_IsOK(ecode3)) {
14554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14555 }
14556 arg3 = static_cast< byte >(val3);
14557 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14558 if (!SWIG_IsOK(ecode4)) {
14559 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14560 }
14561 arg4 = static_cast< byte >(val4);
14562 {
14563 PyThreadState* __tstate = wxPyBeginAllowThreads();
14564 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14565 wxPyEndAllowThreads(__tstate);
14566 if (PyErr_Occurred()) SWIG_fail;
14567 }
14568 {
14569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14570 }
14571 return resultobj;
14572 fail:
14573 return NULL;
14574 }
14575
14576
14577 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14578 PyObject *resultobj = 0;
14579 wxImage *arg1 = (wxImage *) 0 ;
14580 wxImage *arg2 = 0 ;
14581 byte arg3 ;
14582 byte arg4 ;
14583 byte arg5 ;
14584 bool result;
14585 void *argp1 = 0 ;
14586 int res1 = 0 ;
14587 void *argp2 = 0 ;
14588 int res2 = 0 ;
14589 unsigned char val3 ;
14590 int ecode3 = 0 ;
14591 unsigned char val4 ;
14592 int ecode4 = 0 ;
14593 unsigned char val5 ;
14594 int ecode5 = 0 ;
14595 PyObject * obj0 = 0 ;
14596 PyObject * obj1 = 0 ;
14597 PyObject * obj2 = 0 ;
14598 PyObject * obj3 = 0 ;
14599 PyObject * obj4 = 0 ;
14600 char * kwnames[] = {
14601 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14602 };
14603
14604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14606 if (!SWIG_IsOK(res1)) {
14607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14608 }
14609 arg1 = reinterpret_cast< wxImage * >(argp1);
14610 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14611 if (!SWIG_IsOK(res2)) {
14612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14613 }
14614 if (!argp2) {
14615 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14616 }
14617 arg2 = reinterpret_cast< wxImage * >(argp2);
14618 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14619 if (!SWIG_IsOK(ecode3)) {
14620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14621 }
14622 arg3 = static_cast< byte >(val3);
14623 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14624 if (!SWIG_IsOK(ecode4)) {
14625 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14626 }
14627 arg4 = static_cast< byte >(val4);
14628 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14629 if (!SWIG_IsOK(ecode5)) {
14630 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14631 }
14632 arg5 = static_cast< byte >(val5);
14633 {
14634 PyThreadState* __tstate = wxPyBeginAllowThreads();
14635 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14636 wxPyEndAllowThreads(__tstate);
14637 if (PyErr_Occurred()) SWIG_fail;
14638 }
14639 {
14640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14641 }
14642 return resultobj;
14643 fail:
14644 return NULL;
14645 }
14646
14647
14648 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14649 PyObject *resultobj = 0;
14650 wxString *arg1 = 0 ;
14651 bool result;
14652 bool temp1 = false ;
14653 PyObject * obj0 = 0 ;
14654 char * kwnames[] = {
14655 (char *) "filename", NULL
14656 };
14657
14658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14659 {
14660 arg1 = wxString_in_helper(obj0);
14661 if (arg1 == NULL) SWIG_fail;
14662 temp1 = true;
14663 }
14664 {
14665 PyThreadState* __tstate = wxPyBeginAllowThreads();
14666 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14667 wxPyEndAllowThreads(__tstate);
14668 if (PyErr_Occurred()) SWIG_fail;
14669 }
14670 {
14671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14672 }
14673 {
14674 if (temp1)
14675 delete arg1;
14676 }
14677 return resultobj;
14678 fail:
14679 {
14680 if (temp1)
14681 delete arg1;
14682 }
14683 return NULL;
14684 }
14685
14686
14687 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14688 PyObject *resultobj = 0;
14689 wxString *arg1 = 0 ;
14690 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14691 int result;
14692 bool temp1 = false ;
14693 long val2 ;
14694 int ecode2 = 0 ;
14695 PyObject * obj0 = 0 ;
14696 PyObject * obj1 = 0 ;
14697 char * kwnames[] = {
14698 (char *) "filename",(char *) "type", NULL
14699 };
14700
14701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14702 {
14703 arg1 = wxString_in_helper(obj0);
14704 if (arg1 == NULL) SWIG_fail;
14705 temp1 = true;
14706 }
14707 if (obj1) {
14708 ecode2 = SWIG_AsVal_long(obj1, &val2);
14709 if (!SWIG_IsOK(ecode2)) {
14710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14711 }
14712 arg2 = static_cast< long >(val2);
14713 }
14714 {
14715 PyThreadState* __tstate = wxPyBeginAllowThreads();
14716 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14717 wxPyEndAllowThreads(__tstate);
14718 if (PyErr_Occurred()) SWIG_fail;
14719 }
14720 resultobj = SWIG_From_int(static_cast< int >(result));
14721 {
14722 if (temp1)
14723 delete arg1;
14724 }
14725 return resultobj;
14726 fail:
14727 {
14728 if (temp1)
14729 delete arg1;
14730 }
14731 return NULL;
14732 }
14733
14734
14735 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14736 PyObject *resultobj = 0;
14737 wxImage *arg1 = (wxImage *) 0 ;
14738 wxString *arg2 = 0 ;
14739 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14740 int arg4 = (int) -1 ;
14741 bool result;
14742 void *argp1 = 0 ;
14743 int res1 = 0 ;
14744 bool temp2 = false ;
14745 long val3 ;
14746 int ecode3 = 0 ;
14747 int val4 ;
14748 int ecode4 = 0 ;
14749 PyObject * obj0 = 0 ;
14750 PyObject * obj1 = 0 ;
14751 PyObject * obj2 = 0 ;
14752 PyObject * obj3 = 0 ;
14753 char * kwnames[] = {
14754 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14755 };
14756
14757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14759 if (!SWIG_IsOK(res1)) {
14760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14761 }
14762 arg1 = reinterpret_cast< wxImage * >(argp1);
14763 {
14764 arg2 = wxString_in_helper(obj1);
14765 if (arg2 == NULL) SWIG_fail;
14766 temp2 = true;
14767 }
14768 if (obj2) {
14769 ecode3 = SWIG_AsVal_long(obj2, &val3);
14770 if (!SWIG_IsOK(ecode3)) {
14771 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14772 }
14773 arg3 = static_cast< long >(val3);
14774 }
14775 if (obj3) {
14776 ecode4 = SWIG_AsVal_int(obj3, &val4);
14777 if (!SWIG_IsOK(ecode4)) {
14778 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14779 }
14780 arg4 = static_cast< int >(val4);
14781 }
14782 {
14783 PyThreadState* __tstate = wxPyBeginAllowThreads();
14784 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14785 wxPyEndAllowThreads(__tstate);
14786 if (PyErr_Occurred()) SWIG_fail;
14787 }
14788 {
14789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14790 }
14791 {
14792 if (temp2)
14793 delete arg2;
14794 }
14795 return resultobj;
14796 fail:
14797 {
14798 if (temp2)
14799 delete arg2;
14800 }
14801 return NULL;
14802 }
14803
14804
14805 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14806 PyObject *resultobj = 0;
14807 wxImage *arg1 = (wxImage *) 0 ;
14808 wxString *arg2 = 0 ;
14809 wxString *arg3 = 0 ;
14810 int arg4 = (int) -1 ;
14811 bool result;
14812 void *argp1 = 0 ;
14813 int res1 = 0 ;
14814 bool temp2 = false ;
14815 bool temp3 = false ;
14816 int val4 ;
14817 int ecode4 = 0 ;
14818 PyObject * obj0 = 0 ;
14819 PyObject * obj1 = 0 ;
14820 PyObject * obj2 = 0 ;
14821 PyObject * obj3 = 0 ;
14822 char * kwnames[] = {
14823 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14824 };
14825
14826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14828 if (!SWIG_IsOK(res1)) {
14829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14830 }
14831 arg1 = reinterpret_cast< wxImage * >(argp1);
14832 {
14833 arg2 = wxString_in_helper(obj1);
14834 if (arg2 == NULL) SWIG_fail;
14835 temp2 = true;
14836 }
14837 {
14838 arg3 = wxString_in_helper(obj2);
14839 if (arg3 == NULL) SWIG_fail;
14840 temp3 = true;
14841 }
14842 if (obj3) {
14843 ecode4 = SWIG_AsVal_int(obj3, &val4);
14844 if (!SWIG_IsOK(ecode4)) {
14845 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14846 }
14847 arg4 = static_cast< int >(val4);
14848 }
14849 {
14850 PyThreadState* __tstate = wxPyBeginAllowThreads();
14851 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14852 wxPyEndAllowThreads(__tstate);
14853 if (PyErr_Occurred()) SWIG_fail;
14854 }
14855 {
14856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14857 }
14858 {
14859 if (temp2)
14860 delete arg2;
14861 }
14862 {
14863 if (temp3)
14864 delete arg3;
14865 }
14866 return resultobj;
14867 fail:
14868 {
14869 if (temp2)
14870 delete arg2;
14871 }
14872 {
14873 if (temp3)
14874 delete arg3;
14875 }
14876 return NULL;
14877 }
14878
14879
14880 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14881 PyObject *resultobj = 0;
14882 wxImage *arg1 = (wxImage *) 0 ;
14883 wxString *arg2 = 0 ;
14884 int arg3 ;
14885 bool result;
14886 void *argp1 = 0 ;
14887 int res1 = 0 ;
14888 bool temp2 = false ;
14889 int val3 ;
14890 int ecode3 = 0 ;
14891 PyObject * obj0 = 0 ;
14892 PyObject * obj1 = 0 ;
14893 PyObject * obj2 = 0 ;
14894 char * kwnames[] = {
14895 (char *) "self",(char *) "name",(char *) "type", NULL
14896 };
14897
14898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14900 if (!SWIG_IsOK(res1)) {
14901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14902 }
14903 arg1 = reinterpret_cast< wxImage * >(argp1);
14904 {
14905 arg2 = wxString_in_helper(obj1);
14906 if (arg2 == NULL) SWIG_fail;
14907 temp2 = true;
14908 }
14909 ecode3 = SWIG_AsVal_int(obj2, &val3);
14910 if (!SWIG_IsOK(ecode3)) {
14911 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14912 }
14913 arg3 = static_cast< int >(val3);
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14917 wxPyEndAllowThreads(__tstate);
14918 if (PyErr_Occurred()) SWIG_fail;
14919 }
14920 {
14921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14922 }
14923 {
14924 if (temp2)
14925 delete arg2;
14926 }
14927 return resultobj;
14928 fail:
14929 {
14930 if (temp2)
14931 delete arg2;
14932 }
14933 return NULL;
14934 }
14935
14936
14937 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14938 PyObject *resultobj = 0;
14939 wxImage *arg1 = (wxImage *) 0 ;
14940 wxString *arg2 = 0 ;
14941 wxString *arg3 = 0 ;
14942 bool result;
14943 void *argp1 = 0 ;
14944 int res1 = 0 ;
14945 bool temp2 = false ;
14946 bool temp3 = false ;
14947 PyObject * obj0 = 0 ;
14948 PyObject * obj1 = 0 ;
14949 PyObject * obj2 = 0 ;
14950 char * kwnames[] = {
14951 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14952 };
14953
14954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14956 if (!SWIG_IsOK(res1)) {
14957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14958 }
14959 arg1 = reinterpret_cast< wxImage * >(argp1);
14960 {
14961 arg2 = wxString_in_helper(obj1);
14962 if (arg2 == NULL) SWIG_fail;
14963 temp2 = true;
14964 }
14965 {
14966 arg3 = wxString_in_helper(obj2);
14967 if (arg3 == NULL) SWIG_fail;
14968 temp3 = true;
14969 }
14970 {
14971 PyThreadState* __tstate = wxPyBeginAllowThreads();
14972 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14973 wxPyEndAllowThreads(__tstate);
14974 if (PyErr_Occurred()) SWIG_fail;
14975 }
14976 {
14977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14978 }
14979 {
14980 if (temp2)
14981 delete arg2;
14982 }
14983 {
14984 if (temp3)
14985 delete arg3;
14986 }
14987 return resultobj;
14988 fail:
14989 {
14990 if (temp2)
14991 delete arg2;
14992 }
14993 {
14994 if (temp3)
14995 delete arg3;
14996 }
14997 return NULL;
14998 }
14999
15000
15001 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15002 PyObject *resultobj = 0;
15003 wxInputStream *arg1 = 0 ;
15004 bool result;
15005 wxPyInputStream *temp1 ;
15006 bool created1 ;
15007 PyObject * obj0 = 0 ;
15008 char * kwnames[] = {
15009 (char *) "stream", NULL
15010 };
15011
15012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
15013 {
15014 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15015 arg1 = temp1->m_wxis;
15016 created1 = false;
15017 } else {
15018 PyErr_Clear(); // clear the failure of the wxPyConvert above
15019 arg1 = wxPyCBInputStream_create(obj0, false);
15020 if (arg1 == NULL) {
15021 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15022 SWIG_fail;
15023 }
15024 created1 = true;
15025 }
15026 }
15027 {
15028 PyThreadState* __tstate = wxPyBeginAllowThreads();
15029 result = (bool)wxImage::CanRead(*arg1);
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 {
15034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15035 }
15036 {
15037 if (created1) delete arg1;
15038 }
15039 return resultobj;
15040 fail:
15041 {
15042 if (created1) delete arg1;
15043 }
15044 return NULL;
15045 }
15046
15047
15048 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15049 PyObject *resultobj = 0;
15050 wxImage *arg1 = (wxImage *) 0 ;
15051 wxInputStream *arg2 = 0 ;
15052 long arg3 = (long) wxBITMAP_TYPE_ANY ;
15053 int arg4 = (int) -1 ;
15054 bool result;
15055 void *argp1 = 0 ;
15056 int res1 = 0 ;
15057 wxPyInputStream *temp2 ;
15058 bool created2 ;
15059 long val3 ;
15060 int ecode3 = 0 ;
15061 int val4 ;
15062 int ecode4 = 0 ;
15063 PyObject * obj0 = 0 ;
15064 PyObject * obj1 = 0 ;
15065 PyObject * obj2 = 0 ;
15066 PyObject * obj3 = 0 ;
15067 char * kwnames[] = {
15068 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
15069 };
15070
15071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15073 if (!SWIG_IsOK(res1)) {
15074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
15075 }
15076 arg1 = reinterpret_cast< wxImage * >(argp1);
15077 {
15078 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15079 arg2 = temp2->m_wxis;
15080 created2 = false;
15081 } else {
15082 PyErr_Clear(); // clear the failure of the wxPyConvert above
15083 arg2 = wxPyCBInputStream_create(obj1, false);
15084 if (arg2 == NULL) {
15085 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15086 SWIG_fail;
15087 }
15088 created2 = true;
15089 }
15090 }
15091 if (obj2) {
15092 ecode3 = SWIG_AsVal_long(obj2, &val3);
15093 if (!SWIG_IsOK(ecode3)) {
15094 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
15095 }
15096 arg3 = static_cast< long >(val3);
15097 }
15098 if (obj3) {
15099 ecode4 = SWIG_AsVal_int(obj3, &val4);
15100 if (!SWIG_IsOK(ecode4)) {
15101 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
15102 }
15103 arg4 = static_cast< int >(val4);
15104 }
15105 {
15106 PyThreadState* __tstate = wxPyBeginAllowThreads();
15107 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
15108 wxPyEndAllowThreads(__tstate);
15109 if (PyErr_Occurred()) SWIG_fail;
15110 }
15111 {
15112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15113 }
15114 {
15115 if (created2) delete arg2;
15116 }
15117 return resultobj;
15118 fail:
15119 {
15120 if (created2) delete arg2;
15121 }
15122 return NULL;
15123 }
15124
15125
15126 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15127 PyObject *resultobj = 0;
15128 wxImage *arg1 = (wxImage *) 0 ;
15129 wxInputStream *arg2 = 0 ;
15130 wxString *arg3 = 0 ;
15131 int arg4 = (int) -1 ;
15132 bool result;
15133 void *argp1 = 0 ;
15134 int res1 = 0 ;
15135 wxPyInputStream *temp2 ;
15136 bool created2 ;
15137 bool temp3 = false ;
15138 int val4 ;
15139 int ecode4 = 0 ;
15140 PyObject * obj0 = 0 ;
15141 PyObject * obj1 = 0 ;
15142 PyObject * obj2 = 0 ;
15143 PyObject * obj3 = 0 ;
15144 char * kwnames[] = {
15145 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15146 };
15147
15148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15150 if (!SWIG_IsOK(res1)) {
15151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15152 }
15153 arg1 = reinterpret_cast< wxImage * >(argp1);
15154 {
15155 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15156 arg2 = temp2->m_wxis;
15157 created2 = false;
15158 } else {
15159 PyErr_Clear(); // clear the failure of the wxPyConvert above
15160 arg2 = wxPyCBInputStream_create(obj1, false);
15161 if (arg2 == NULL) {
15162 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15163 SWIG_fail;
15164 }
15165 created2 = true;
15166 }
15167 }
15168 {
15169 arg3 = wxString_in_helper(obj2);
15170 if (arg3 == NULL) SWIG_fail;
15171 temp3 = true;
15172 }
15173 if (obj3) {
15174 ecode4 = SWIG_AsVal_int(obj3, &val4);
15175 if (!SWIG_IsOK(ecode4)) {
15176 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15177 }
15178 arg4 = static_cast< int >(val4);
15179 }
15180 {
15181 PyThreadState* __tstate = wxPyBeginAllowThreads();
15182 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15183 wxPyEndAllowThreads(__tstate);
15184 if (PyErr_Occurred()) SWIG_fail;
15185 }
15186 {
15187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15188 }
15189 {
15190 if (created2) delete arg2;
15191 }
15192 {
15193 if (temp3)
15194 delete arg3;
15195 }
15196 return resultobj;
15197 fail:
15198 {
15199 if (created2) delete arg2;
15200 }
15201 {
15202 if (temp3)
15203 delete arg3;
15204 }
15205 return NULL;
15206 }
15207
15208
15209 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15210 PyObject *resultobj = 0;
15211 wxImage *arg1 = (wxImage *) 0 ;
15212 bool result;
15213 void *argp1 = 0 ;
15214 int res1 = 0 ;
15215 PyObject *swig_obj[1] ;
15216
15217 if (!args) SWIG_fail;
15218 swig_obj[0] = args;
15219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15220 if (!SWIG_IsOK(res1)) {
15221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15222 }
15223 arg1 = reinterpret_cast< wxImage * >(argp1);
15224 {
15225 PyThreadState* __tstate = wxPyBeginAllowThreads();
15226 result = (bool)(arg1)->Ok();
15227 wxPyEndAllowThreads(__tstate);
15228 if (PyErr_Occurred()) SWIG_fail;
15229 }
15230 {
15231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15232 }
15233 return resultobj;
15234 fail:
15235 return NULL;
15236 }
15237
15238
15239 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15240 PyObject *resultobj = 0;
15241 wxImage *arg1 = (wxImage *) 0 ;
15242 int result;
15243 void *argp1 = 0 ;
15244 int res1 = 0 ;
15245 PyObject *swig_obj[1] ;
15246
15247 if (!args) SWIG_fail;
15248 swig_obj[0] = args;
15249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15250 if (!SWIG_IsOK(res1)) {
15251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15252 }
15253 arg1 = reinterpret_cast< wxImage * >(argp1);
15254 {
15255 PyThreadState* __tstate = wxPyBeginAllowThreads();
15256 result = (int)(arg1)->GetWidth();
15257 wxPyEndAllowThreads(__tstate);
15258 if (PyErr_Occurred()) SWIG_fail;
15259 }
15260 resultobj = SWIG_From_int(static_cast< int >(result));
15261 return resultobj;
15262 fail:
15263 return NULL;
15264 }
15265
15266
15267 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15268 PyObject *resultobj = 0;
15269 wxImage *arg1 = (wxImage *) 0 ;
15270 int result;
15271 void *argp1 = 0 ;
15272 int res1 = 0 ;
15273 PyObject *swig_obj[1] ;
15274
15275 if (!args) SWIG_fail;
15276 swig_obj[0] = args;
15277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15278 if (!SWIG_IsOK(res1)) {
15279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15280 }
15281 arg1 = reinterpret_cast< wxImage * >(argp1);
15282 {
15283 PyThreadState* __tstate = wxPyBeginAllowThreads();
15284 result = (int)(arg1)->GetHeight();
15285 wxPyEndAllowThreads(__tstate);
15286 if (PyErr_Occurred()) SWIG_fail;
15287 }
15288 resultobj = SWIG_From_int(static_cast< int >(result));
15289 return resultobj;
15290 fail:
15291 return NULL;
15292 }
15293
15294
15295 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15296 PyObject *resultobj = 0;
15297 wxImage *arg1 = (wxImage *) 0 ;
15298 wxSize result;
15299 void *argp1 = 0 ;
15300 int res1 = 0 ;
15301 PyObject *swig_obj[1] ;
15302
15303 if (!args) SWIG_fail;
15304 swig_obj[0] = args;
15305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15306 if (!SWIG_IsOK(res1)) {
15307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15308 }
15309 arg1 = reinterpret_cast< wxImage * >(argp1);
15310 {
15311 PyThreadState* __tstate = wxPyBeginAllowThreads();
15312 result = wxImage_GetSize(arg1);
15313 wxPyEndAllowThreads(__tstate);
15314 if (PyErr_Occurred()) SWIG_fail;
15315 }
15316 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15317 return resultobj;
15318 fail:
15319 return NULL;
15320 }
15321
15322
15323 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15324 PyObject *resultobj = 0;
15325 wxImage *arg1 = (wxImage *) 0 ;
15326 wxRect *arg2 = 0 ;
15327 SwigValueWrapper<wxImage > result;
15328 void *argp1 = 0 ;
15329 int res1 = 0 ;
15330 wxRect temp2 ;
15331 PyObject * obj0 = 0 ;
15332 PyObject * obj1 = 0 ;
15333 char * kwnames[] = {
15334 (char *) "self",(char *) "rect", NULL
15335 };
15336
15337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15339 if (!SWIG_IsOK(res1)) {
15340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15341 }
15342 arg1 = reinterpret_cast< wxImage * >(argp1);
15343 {
15344 arg2 = &temp2;
15345 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15346 }
15347 {
15348 PyThreadState* __tstate = wxPyBeginAllowThreads();
15349 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15350 wxPyEndAllowThreads(__tstate);
15351 if (PyErr_Occurred()) SWIG_fail;
15352 }
15353 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15354 return resultobj;
15355 fail:
15356 return NULL;
15357 }
15358
15359
15360 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15361 PyObject *resultobj = 0;
15362 wxImage *arg1 = (wxImage *) 0 ;
15363 wxSize *arg2 = 0 ;
15364 wxPoint *arg3 = 0 ;
15365 int arg4 = (int) -1 ;
15366 int arg5 = (int) -1 ;
15367 int arg6 = (int) -1 ;
15368 SwigValueWrapper<wxImage > result;
15369 void *argp1 = 0 ;
15370 int res1 = 0 ;
15371 wxSize temp2 ;
15372 wxPoint temp3 ;
15373 int val4 ;
15374 int ecode4 = 0 ;
15375 int val5 ;
15376 int ecode5 = 0 ;
15377 int val6 ;
15378 int ecode6 = 0 ;
15379 PyObject * obj0 = 0 ;
15380 PyObject * obj1 = 0 ;
15381 PyObject * obj2 = 0 ;
15382 PyObject * obj3 = 0 ;
15383 PyObject * obj4 = 0 ;
15384 PyObject * obj5 = 0 ;
15385 char * kwnames[] = {
15386 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15387 };
15388
15389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15391 if (!SWIG_IsOK(res1)) {
15392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15393 }
15394 arg1 = reinterpret_cast< wxImage * >(argp1);
15395 {
15396 arg2 = &temp2;
15397 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15398 }
15399 {
15400 arg3 = &temp3;
15401 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15402 }
15403 if (obj3) {
15404 ecode4 = SWIG_AsVal_int(obj3, &val4);
15405 if (!SWIG_IsOK(ecode4)) {
15406 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15407 }
15408 arg4 = static_cast< int >(val4);
15409 }
15410 if (obj4) {
15411 ecode5 = SWIG_AsVal_int(obj4, &val5);
15412 if (!SWIG_IsOK(ecode5)) {
15413 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15414 }
15415 arg5 = static_cast< int >(val5);
15416 }
15417 if (obj5) {
15418 ecode6 = SWIG_AsVal_int(obj5, &val6);
15419 if (!SWIG_IsOK(ecode6)) {
15420 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15421 }
15422 arg6 = static_cast< int >(val6);
15423 }
15424 {
15425 PyThreadState* __tstate = wxPyBeginAllowThreads();
15426 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15427 wxPyEndAllowThreads(__tstate);
15428 if (PyErr_Occurred()) SWIG_fail;
15429 }
15430 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15431 return resultobj;
15432 fail:
15433 return NULL;
15434 }
15435
15436
15437 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15438 PyObject *resultobj = 0;
15439 wxImage *arg1 = (wxImage *) 0 ;
15440 SwigValueWrapper<wxImage > result;
15441 void *argp1 = 0 ;
15442 int res1 = 0 ;
15443 PyObject *swig_obj[1] ;
15444
15445 if (!args) SWIG_fail;
15446 swig_obj[0] = args;
15447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15448 if (!SWIG_IsOK(res1)) {
15449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15450 }
15451 arg1 = reinterpret_cast< wxImage * >(argp1);
15452 {
15453 PyThreadState* __tstate = wxPyBeginAllowThreads();
15454 result = (arg1)->Copy();
15455 wxPyEndAllowThreads(__tstate);
15456 if (PyErr_Occurred()) SWIG_fail;
15457 }
15458 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15459 return resultobj;
15460 fail:
15461 return NULL;
15462 }
15463
15464
15465 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15466 PyObject *resultobj = 0;
15467 wxImage *arg1 = (wxImage *) 0 ;
15468 wxImage *arg2 = 0 ;
15469 int arg3 ;
15470 int arg4 ;
15471 void *argp1 = 0 ;
15472 int res1 = 0 ;
15473 void *argp2 = 0 ;
15474 int res2 = 0 ;
15475 int val3 ;
15476 int ecode3 = 0 ;
15477 int val4 ;
15478 int ecode4 = 0 ;
15479 PyObject * obj0 = 0 ;
15480 PyObject * obj1 = 0 ;
15481 PyObject * obj2 = 0 ;
15482 PyObject * obj3 = 0 ;
15483 char * kwnames[] = {
15484 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15485 };
15486
15487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15489 if (!SWIG_IsOK(res1)) {
15490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15491 }
15492 arg1 = reinterpret_cast< wxImage * >(argp1);
15493 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15494 if (!SWIG_IsOK(res2)) {
15495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15496 }
15497 if (!argp2) {
15498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15499 }
15500 arg2 = reinterpret_cast< wxImage * >(argp2);
15501 ecode3 = SWIG_AsVal_int(obj2, &val3);
15502 if (!SWIG_IsOK(ecode3)) {
15503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15504 }
15505 arg3 = static_cast< int >(val3);
15506 ecode4 = SWIG_AsVal_int(obj3, &val4);
15507 if (!SWIG_IsOK(ecode4)) {
15508 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15509 }
15510 arg4 = static_cast< int >(val4);
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 resultobj = SWIG_Py_Void();
15518 return resultobj;
15519 fail:
15520 return NULL;
15521 }
15522
15523
15524 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15525 PyObject *resultobj = 0;
15526 wxImage *arg1 = (wxImage *) 0 ;
15527 PyObject *result = 0 ;
15528 void *argp1 = 0 ;
15529 int res1 = 0 ;
15530 PyObject *swig_obj[1] ;
15531
15532 if (!args) SWIG_fail;
15533 swig_obj[0] = args;
15534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15535 if (!SWIG_IsOK(res1)) {
15536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15537 }
15538 arg1 = reinterpret_cast< wxImage * >(argp1);
15539 {
15540 PyThreadState* __tstate = wxPyBeginAllowThreads();
15541 result = (PyObject *)wxImage_GetData(arg1);
15542 wxPyEndAllowThreads(__tstate);
15543 if (PyErr_Occurred()) SWIG_fail;
15544 }
15545 resultobj = result;
15546 return resultobj;
15547 fail:
15548 return NULL;
15549 }
15550
15551
15552 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15553 PyObject *resultobj = 0;
15554 wxImage *arg1 = (wxImage *) 0 ;
15555 buffer arg2 ;
15556 int arg3 ;
15557 void *argp1 = 0 ;
15558 int res1 = 0 ;
15559 Py_ssize_t temp2 ;
15560 PyObject * obj0 = 0 ;
15561 PyObject * obj1 = 0 ;
15562 char * kwnames[] = {
15563 (char *) "self",(char *) "data", NULL
15564 };
15565
15566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15570 }
15571 arg1 = reinterpret_cast< wxImage * >(argp1);
15572 {
15573 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15574 arg3 = (int)temp2;
15575 }
15576 {
15577 PyThreadState* __tstate = wxPyBeginAllowThreads();
15578 wxImage_SetData(arg1,arg2,arg3);
15579 wxPyEndAllowThreads(__tstate);
15580 if (PyErr_Occurred()) SWIG_fail;
15581 }
15582 resultobj = SWIG_Py_Void();
15583 return resultobj;
15584 fail:
15585 return NULL;
15586 }
15587
15588
15589 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15590 PyObject *resultobj = 0;
15591 wxImage *arg1 = (wxImage *) 0 ;
15592 PyObject *result = 0 ;
15593 void *argp1 = 0 ;
15594 int res1 = 0 ;
15595 PyObject *swig_obj[1] ;
15596
15597 if (!args) SWIG_fail;
15598 swig_obj[0] = args;
15599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15600 if (!SWIG_IsOK(res1)) {
15601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15602 }
15603 arg1 = reinterpret_cast< wxImage * >(argp1);
15604 {
15605 PyThreadState* __tstate = wxPyBeginAllowThreads();
15606 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15607 wxPyEndAllowThreads(__tstate);
15608 if (PyErr_Occurred()) SWIG_fail;
15609 }
15610 resultobj = result;
15611 return resultobj;
15612 fail:
15613 return NULL;
15614 }
15615
15616
15617 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15618 PyObject *resultobj = 0;
15619 wxImage *arg1 = (wxImage *) 0 ;
15620 buffer arg2 ;
15621 int arg3 ;
15622 void *argp1 = 0 ;
15623 int res1 = 0 ;
15624 Py_ssize_t temp2 ;
15625 PyObject * obj0 = 0 ;
15626 PyObject * obj1 = 0 ;
15627 char * kwnames[] = {
15628 (char *) "self",(char *) "data", NULL
15629 };
15630
15631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15633 if (!SWIG_IsOK(res1)) {
15634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15635 }
15636 arg1 = reinterpret_cast< wxImage * >(argp1);
15637 {
15638 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15639 arg3 = (int)temp2;
15640 }
15641 {
15642 PyThreadState* __tstate = wxPyBeginAllowThreads();
15643 wxImage_SetDataBuffer(arg1,arg2,arg3);
15644 wxPyEndAllowThreads(__tstate);
15645 if (PyErr_Occurred()) SWIG_fail;
15646 }
15647 resultobj = SWIG_Py_Void();
15648 return resultobj;
15649 fail:
15650 return NULL;
15651 }
15652
15653
15654 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15655 PyObject *resultobj = 0;
15656 wxImage *arg1 = (wxImage *) 0 ;
15657 PyObject *result = 0 ;
15658 void *argp1 = 0 ;
15659 int res1 = 0 ;
15660 PyObject *swig_obj[1] ;
15661
15662 if (!args) SWIG_fail;
15663 swig_obj[0] = args;
15664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15665 if (!SWIG_IsOK(res1)) {
15666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15667 }
15668 arg1 = reinterpret_cast< wxImage * >(argp1);
15669 {
15670 PyThreadState* __tstate = wxPyBeginAllowThreads();
15671 result = (PyObject *)wxImage_GetAlphaData(arg1);
15672 wxPyEndAllowThreads(__tstate);
15673 if (PyErr_Occurred()) SWIG_fail;
15674 }
15675 resultobj = result;
15676 return resultobj;
15677 fail:
15678 return NULL;
15679 }
15680
15681
15682 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15683 PyObject *resultobj = 0;
15684 wxImage *arg1 = (wxImage *) 0 ;
15685 buffer arg2 ;
15686 int arg3 ;
15687 void *argp1 = 0 ;
15688 int res1 = 0 ;
15689 Py_ssize_t temp2 ;
15690 PyObject * obj0 = 0 ;
15691 PyObject * obj1 = 0 ;
15692 char * kwnames[] = {
15693 (char *) "self",(char *) "alpha", NULL
15694 };
15695
15696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15698 if (!SWIG_IsOK(res1)) {
15699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15700 }
15701 arg1 = reinterpret_cast< wxImage * >(argp1);
15702 {
15703 if (obj1 != Py_None) {
15704 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15705 arg3 = (int)temp2;
15706 }
15707 }
15708 {
15709 PyThreadState* __tstate = wxPyBeginAllowThreads();
15710 wxImage_SetAlphaData(arg1,arg2,arg3);
15711 wxPyEndAllowThreads(__tstate);
15712 if (PyErr_Occurred()) SWIG_fail;
15713 }
15714 resultobj = SWIG_Py_Void();
15715 return resultobj;
15716 fail:
15717 return NULL;
15718 }
15719
15720
15721 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15722 PyObject *resultobj = 0;
15723 wxImage *arg1 = (wxImage *) 0 ;
15724 PyObject *result = 0 ;
15725 void *argp1 = 0 ;
15726 int res1 = 0 ;
15727 PyObject *swig_obj[1] ;
15728
15729 if (!args) SWIG_fail;
15730 swig_obj[0] = args;
15731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15732 if (!SWIG_IsOK(res1)) {
15733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15734 }
15735 arg1 = reinterpret_cast< wxImage * >(argp1);
15736 {
15737 PyThreadState* __tstate = wxPyBeginAllowThreads();
15738 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15739 wxPyEndAllowThreads(__tstate);
15740 if (PyErr_Occurred()) SWIG_fail;
15741 }
15742 resultobj = result;
15743 return resultobj;
15744 fail:
15745 return NULL;
15746 }
15747
15748
15749 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15750 PyObject *resultobj = 0;
15751 wxImage *arg1 = (wxImage *) 0 ;
15752 buffer arg2 ;
15753 int arg3 ;
15754 void *argp1 = 0 ;
15755 int res1 = 0 ;
15756 Py_ssize_t temp2 ;
15757 PyObject * obj0 = 0 ;
15758 PyObject * obj1 = 0 ;
15759 char * kwnames[] = {
15760 (char *) "self",(char *) "alpha", NULL
15761 };
15762
15763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15765 if (!SWIG_IsOK(res1)) {
15766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15767 }
15768 arg1 = reinterpret_cast< wxImage * >(argp1);
15769 {
15770 if (obj1 != Py_None) {
15771 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
15772 arg3 = (int)temp2;
15773 }
15774 }
15775 {
15776 PyThreadState* __tstate = wxPyBeginAllowThreads();
15777 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15778 wxPyEndAllowThreads(__tstate);
15779 if (PyErr_Occurred()) SWIG_fail;
15780 }
15781 resultobj = SWIG_Py_Void();
15782 return resultobj;
15783 fail:
15784 return NULL;
15785 }
15786
15787
15788 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15789 PyObject *resultobj = 0;
15790 wxImage *arg1 = (wxImage *) 0 ;
15791 byte arg2 ;
15792 byte arg3 ;
15793 byte arg4 ;
15794 void *argp1 = 0 ;
15795 int res1 = 0 ;
15796 unsigned char val2 ;
15797 int ecode2 = 0 ;
15798 unsigned char val3 ;
15799 int ecode3 = 0 ;
15800 unsigned char val4 ;
15801 int ecode4 = 0 ;
15802 PyObject * obj0 = 0 ;
15803 PyObject * obj1 = 0 ;
15804 PyObject * obj2 = 0 ;
15805 PyObject * obj3 = 0 ;
15806 char * kwnames[] = {
15807 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15808 };
15809
15810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15812 if (!SWIG_IsOK(res1)) {
15813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15814 }
15815 arg1 = reinterpret_cast< wxImage * >(argp1);
15816 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15817 if (!SWIG_IsOK(ecode2)) {
15818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15819 }
15820 arg2 = static_cast< byte >(val2);
15821 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15822 if (!SWIG_IsOK(ecode3)) {
15823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15824 }
15825 arg3 = static_cast< byte >(val3);
15826 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15827 if (!SWIG_IsOK(ecode4)) {
15828 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15829 }
15830 arg4 = static_cast< byte >(val4);
15831 {
15832 PyThreadState* __tstate = wxPyBeginAllowThreads();
15833 (arg1)->SetMaskColour(arg2,arg3,arg4);
15834 wxPyEndAllowThreads(__tstate);
15835 if (PyErr_Occurred()) SWIG_fail;
15836 }
15837 resultobj = SWIG_Py_Void();
15838 return resultobj;
15839 fail:
15840 return NULL;
15841 }
15842
15843
15844 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15845 PyObject *resultobj = 0;
15846 wxImage *arg1 = (wxImage *) 0 ;
15847 byte *arg2 = (byte *) 0 ;
15848 byte *arg3 = (byte *) 0 ;
15849 byte *arg4 = (byte *) 0 ;
15850 void *argp1 = 0 ;
15851 int res1 = 0 ;
15852 byte temp2 ;
15853 int res2 = SWIG_TMPOBJ ;
15854 byte temp3 ;
15855 int res3 = SWIG_TMPOBJ ;
15856 byte temp4 ;
15857 int res4 = SWIG_TMPOBJ ;
15858 PyObject *swig_obj[1] ;
15859
15860 arg2 = &temp2;
15861 arg3 = &temp3;
15862 arg4 = &temp4;
15863 if (!args) SWIG_fail;
15864 swig_obj[0] = args;
15865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15866 if (!SWIG_IsOK(res1)) {
15867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15868 }
15869 arg1 = reinterpret_cast< wxImage * >(argp1);
15870 {
15871 PyThreadState* __tstate = wxPyBeginAllowThreads();
15872 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15873 wxPyEndAllowThreads(__tstate);
15874 if (PyErr_Occurred()) SWIG_fail;
15875 }
15876 resultobj = SWIG_Py_Void();
15877 if (SWIG_IsTmpObj(res2)) {
15878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15879 } else {
15880 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15882 }
15883 if (SWIG_IsTmpObj(res3)) {
15884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15885 } else {
15886 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15888 }
15889 if (SWIG_IsTmpObj(res4)) {
15890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15891 } else {
15892 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15894 }
15895 return resultobj;
15896 fail:
15897 return NULL;
15898 }
15899
15900
15901 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15902 PyObject *resultobj = 0;
15903 wxImage *arg1 = (wxImage *) 0 ;
15904 byte result;
15905 void *argp1 = 0 ;
15906 int res1 = 0 ;
15907 PyObject *swig_obj[1] ;
15908
15909 if (!args) SWIG_fail;
15910 swig_obj[0] = args;
15911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15912 if (!SWIG_IsOK(res1)) {
15913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15914 }
15915 arg1 = reinterpret_cast< wxImage * >(argp1);
15916 {
15917 PyThreadState* __tstate = wxPyBeginAllowThreads();
15918 result = (byte)(arg1)->GetMaskRed();
15919 wxPyEndAllowThreads(__tstate);
15920 if (PyErr_Occurred()) SWIG_fail;
15921 }
15922 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15923 return resultobj;
15924 fail:
15925 return NULL;
15926 }
15927
15928
15929 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15930 PyObject *resultobj = 0;
15931 wxImage *arg1 = (wxImage *) 0 ;
15932 byte result;
15933 void *argp1 = 0 ;
15934 int res1 = 0 ;
15935 PyObject *swig_obj[1] ;
15936
15937 if (!args) SWIG_fail;
15938 swig_obj[0] = args;
15939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15940 if (!SWIG_IsOK(res1)) {
15941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15942 }
15943 arg1 = reinterpret_cast< wxImage * >(argp1);
15944 {
15945 PyThreadState* __tstate = wxPyBeginAllowThreads();
15946 result = (byte)(arg1)->GetMaskGreen();
15947 wxPyEndAllowThreads(__tstate);
15948 if (PyErr_Occurred()) SWIG_fail;
15949 }
15950 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15951 return resultobj;
15952 fail:
15953 return NULL;
15954 }
15955
15956
15957 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15958 PyObject *resultobj = 0;
15959 wxImage *arg1 = (wxImage *) 0 ;
15960 byte result;
15961 void *argp1 = 0 ;
15962 int res1 = 0 ;
15963 PyObject *swig_obj[1] ;
15964
15965 if (!args) SWIG_fail;
15966 swig_obj[0] = args;
15967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15968 if (!SWIG_IsOK(res1)) {
15969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15970 }
15971 arg1 = reinterpret_cast< wxImage * >(argp1);
15972 {
15973 PyThreadState* __tstate = wxPyBeginAllowThreads();
15974 result = (byte)(arg1)->GetMaskBlue();
15975 wxPyEndAllowThreads(__tstate);
15976 if (PyErr_Occurred()) SWIG_fail;
15977 }
15978 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15979 return resultobj;
15980 fail:
15981 return NULL;
15982 }
15983
15984
15985 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15986 PyObject *resultobj = 0;
15987 wxImage *arg1 = (wxImage *) 0 ;
15988 bool arg2 = (bool) true ;
15989 void *argp1 = 0 ;
15990 int res1 = 0 ;
15991 bool val2 ;
15992 int ecode2 = 0 ;
15993 PyObject * obj0 = 0 ;
15994 PyObject * obj1 = 0 ;
15995 char * kwnames[] = {
15996 (char *) "self",(char *) "mask", NULL
15997 };
15998
15999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
16000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16001 if (!SWIG_IsOK(res1)) {
16002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
16003 }
16004 arg1 = reinterpret_cast< wxImage * >(argp1);
16005 if (obj1) {
16006 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16007 if (!SWIG_IsOK(ecode2)) {
16008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
16009 }
16010 arg2 = static_cast< bool >(val2);
16011 }
16012 {
16013 PyThreadState* __tstate = wxPyBeginAllowThreads();
16014 (arg1)->SetMask(arg2);
16015 wxPyEndAllowThreads(__tstate);
16016 if (PyErr_Occurred()) SWIG_fail;
16017 }
16018 resultobj = SWIG_Py_Void();
16019 return resultobj;
16020 fail:
16021 return NULL;
16022 }
16023
16024
16025 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16026 PyObject *resultobj = 0;
16027 wxImage *arg1 = (wxImage *) 0 ;
16028 bool result;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 PyObject *swig_obj[1] ;
16032
16033 if (!args) SWIG_fail;
16034 swig_obj[0] = args;
16035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16036 if (!SWIG_IsOK(res1)) {
16037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
16038 }
16039 arg1 = reinterpret_cast< wxImage * >(argp1);
16040 {
16041 PyThreadState* __tstate = wxPyBeginAllowThreads();
16042 result = (bool)(arg1)->HasMask();
16043 wxPyEndAllowThreads(__tstate);
16044 if (PyErr_Occurred()) SWIG_fail;
16045 }
16046 {
16047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16048 }
16049 return resultobj;
16050 fail:
16051 return NULL;
16052 }
16053
16054
16055 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16056 PyObject *resultobj = 0;
16057 wxImage *arg1 = (wxImage *) 0 ;
16058 double arg2 ;
16059 wxPoint *arg3 = 0 ;
16060 bool arg4 = (bool) true ;
16061 wxPoint *arg5 = (wxPoint *) NULL ;
16062 SwigValueWrapper<wxImage > result;
16063 void *argp1 = 0 ;
16064 int res1 = 0 ;
16065 double val2 ;
16066 int ecode2 = 0 ;
16067 wxPoint temp3 ;
16068 bool val4 ;
16069 int ecode4 = 0 ;
16070 void *argp5 = 0 ;
16071 int res5 = 0 ;
16072 PyObject * obj0 = 0 ;
16073 PyObject * obj1 = 0 ;
16074 PyObject * obj2 = 0 ;
16075 PyObject * obj3 = 0 ;
16076 PyObject * obj4 = 0 ;
16077 char * kwnames[] = {
16078 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
16079 };
16080
16081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16083 if (!SWIG_IsOK(res1)) {
16084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
16085 }
16086 arg1 = reinterpret_cast< wxImage * >(argp1);
16087 ecode2 = SWIG_AsVal_double(obj1, &val2);
16088 if (!SWIG_IsOK(ecode2)) {
16089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
16090 }
16091 arg2 = static_cast< double >(val2);
16092 {
16093 arg3 = &temp3;
16094 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16095 }
16096 if (obj3) {
16097 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16098 if (!SWIG_IsOK(ecode4)) {
16099 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
16100 }
16101 arg4 = static_cast< bool >(val4);
16102 }
16103 if (obj4) {
16104 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
16105 if (!SWIG_IsOK(res5)) {
16106 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
16107 }
16108 arg5 = reinterpret_cast< wxPoint * >(argp5);
16109 }
16110 {
16111 PyThreadState* __tstate = wxPyBeginAllowThreads();
16112 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
16113 wxPyEndAllowThreads(__tstate);
16114 if (PyErr_Occurred()) SWIG_fail;
16115 }
16116 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16117 return resultobj;
16118 fail:
16119 return NULL;
16120 }
16121
16122
16123 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16124 PyObject *resultobj = 0;
16125 wxImage *arg1 = (wxImage *) 0 ;
16126 bool arg2 = (bool) true ;
16127 SwigValueWrapper<wxImage > result;
16128 void *argp1 = 0 ;
16129 int res1 = 0 ;
16130 bool val2 ;
16131 int ecode2 = 0 ;
16132 PyObject * obj0 = 0 ;
16133 PyObject * obj1 = 0 ;
16134 char * kwnames[] = {
16135 (char *) "self",(char *) "clockwise", NULL
16136 };
16137
16138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16140 if (!SWIG_IsOK(res1)) {
16141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16142 }
16143 arg1 = reinterpret_cast< wxImage * >(argp1);
16144 if (obj1) {
16145 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16146 if (!SWIG_IsOK(ecode2)) {
16147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16148 }
16149 arg2 = static_cast< bool >(val2);
16150 }
16151 {
16152 PyThreadState* __tstate = wxPyBeginAllowThreads();
16153 result = (arg1)->Rotate90(arg2);
16154 wxPyEndAllowThreads(__tstate);
16155 if (PyErr_Occurred()) SWIG_fail;
16156 }
16157 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16158 return resultobj;
16159 fail:
16160 return NULL;
16161 }
16162
16163
16164 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16165 PyObject *resultobj = 0;
16166 wxImage *arg1 = (wxImage *) 0 ;
16167 bool arg2 = (bool) true ;
16168 SwigValueWrapper<wxImage > result;
16169 void *argp1 = 0 ;
16170 int res1 = 0 ;
16171 bool val2 ;
16172 int ecode2 = 0 ;
16173 PyObject * obj0 = 0 ;
16174 PyObject * obj1 = 0 ;
16175 char * kwnames[] = {
16176 (char *) "self",(char *) "horizontally", NULL
16177 };
16178
16179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16181 if (!SWIG_IsOK(res1)) {
16182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16183 }
16184 arg1 = reinterpret_cast< wxImage * >(argp1);
16185 if (obj1) {
16186 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16187 if (!SWIG_IsOK(ecode2)) {
16188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16189 }
16190 arg2 = static_cast< bool >(val2);
16191 }
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 result = (arg1)->Mirror(arg2);
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16199 return resultobj;
16200 fail:
16201 return NULL;
16202 }
16203
16204
16205 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16206 PyObject *resultobj = 0;
16207 wxImage *arg1 = (wxImage *) 0 ;
16208 byte arg2 ;
16209 byte arg3 ;
16210 byte arg4 ;
16211 byte arg5 ;
16212 byte arg6 ;
16213 byte arg7 ;
16214 void *argp1 = 0 ;
16215 int res1 = 0 ;
16216 unsigned char val2 ;
16217 int ecode2 = 0 ;
16218 unsigned char val3 ;
16219 int ecode3 = 0 ;
16220 unsigned char val4 ;
16221 int ecode4 = 0 ;
16222 unsigned char val5 ;
16223 int ecode5 = 0 ;
16224 unsigned char val6 ;
16225 int ecode6 = 0 ;
16226 unsigned char val7 ;
16227 int ecode7 = 0 ;
16228 PyObject * obj0 = 0 ;
16229 PyObject * obj1 = 0 ;
16230 PyObject * obj2 = 0 ;
16231 PyObject * obj3 = 0 ;
16232 PyObject * obj4 = 0 ;
16233 PyObject * obj5 = 0 ;
16234 PyObject * obj6 = 0 ;
16235 char * kwnames[] = {
16236 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16237 };
16238
16239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16241 if (!SWIG_IsOK(res1)) {
16242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16243 }
16244 arg1 = reinterpret_cast< wxImage * >(argp1);
16245 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16246 if (!SWIG_IsOK(ecode2)) {
16247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16248 }
16249 arg2 = static_cast< byte >(val2);
16250 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16251 if (!SWIG_IsOK(ecode3)) {
16252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16253 }
16254 arg3 = static_cast< byte >(val3);
16255 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16256 if (!SWIG_IsOK(ecode4)) {
16257 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16258 }
16259 arg4 = static_cast< byte >(val4);
16260 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16261 if (!SWIG_IsOK(ecode5)) {
16262 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16263 }
16264 arg5 = static_cast< byte >(val5);
16265 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16266 if (!SWIG_IsOK(ecode6)) {
16267 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16268 }
16269 arg6 = static_cast< byte >(val6);
16270 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16271 if (!SWIG_IsOK(ecode7)) {
16272 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16273 }
16274 arg7 = static_cast< byte >(val7);
16275 {
16276 PyThreadState* __tstate = wxPyBeginAllowThreads();
16277 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16278 wxPyEndAllowThreads(__tstate);
16279 if (PyErr_Occurred()) SWIG_fail;
16280 }
16281 resultobj = SWIG_Py_Void();
16282 return resultobj;
16283 fail:
16284 return NULL;
16285 }
16286
16287
16288 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16289 PyObject *resultobj = 0;
16290 wxImage *arg1 = (wxImage *) 0 ;
16291 double arg2 = (double) 0.299 ;
16292 double arg3 = (double) 0.587 ;
16293 double arg4 = (double) 0.114 ;
16294 SwigValueWrapper<wxImage > result;
16295 void *argp1 = 0 ;
16296 int res1 = 0 ;
16297 double val2 ;
16298 int ecode2 = 0 ;
16299 double val3 ;
16300 int ecode3 = 0 ;
16301 double val4 ;
16302 int ecode4 = 0 ;
16303 PyObject * obj0 = 0 ;
16304 PyObject * obj1 = 0 ;
16305 PyObject * obj2 = 0 ;
16306 PyObject * obj3 = 0 ;
16307 char * kwnames[] = {
16308 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16309 };
16310
16311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16313 if (!SWIG_IsOK(res1)) {
16314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16315 }
16316 arg1 = reinterpret_cast< wxImage * >(argp1);
16317 if (obj1) {
16318 ecode2 = SWIG_AsVal_double(obj1, &val2);
16319 if (!SWIG_IsOK(ecode2)) {
16320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16321 }
16322 arg2 = static_cast< double >(val2);
16323 }
16324 if (obj2) {
16325 ecode3 = SWIG_AsVal_double(obj2, &val3);
16326 if (!SWIG_IsOK(ecode3)) {
16327 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16328 }
16329 arg3 = static_cast< double >(val3);
16330 }
16331 if (obj3) {
16332 ecode4 = SWIG_AsVal_double(obj3, &val4);
16333 if (!SWIG_IsOK(ecode4)) {
16334 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16335 }
16336 arg4 = static_cast< double >(val4);
16337 }
16338 {
16339 PyThreadState* __tstate = wxPyBeginAllowThreads();
16340 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16341 wxPyEndAllowThreads(__tstate);
16342 if (PyErr_Occurred()) SWIG_fail;
16343 }
16344 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16345 return resultobj;
16346 fail:
16347 return NULL;
16348 }
16349
16350
16351 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16352 PyObject *resultobj = 0;
16353 wxImage *arg1 = (wxImage *) 0 ;
16354 byte arg2 ;
16355 byte arg3 ;
16356 byte arg4 ;
16357 SwigValueWrapper<wxImage > result;
16358 void *argp1 = 0 ;
16359 int res1 = 0 ;
16360 unsigned char val2 ;
16361 int ecode2 = 0 ;
16362 unsigned char val3 ;
16363 int ecode3 = 0 ;
16364 unsigned char val4 ;
16365 int ecode4 = 0 ;
16366 PyObject * obj0 = 0 ;
16367 PyObject * obj1 = 0 ;
16368 PyObject * obj2 = 0 ;
16369 PyObject * obj3 = 0 ;
16370 char * kwnames[] = {
16371 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16372 };
16373
16374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16376 if (!SWIG_IsOK(res1)) {
16377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16378 }
16379 arg1 = reinterpret_cast< wxImage * >(argp1);
16380 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16381 if (!SWIG_IsOK(ecode2)) {
16382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16383 }
16384 arg2 = static_cast< byte >(val2);
16385 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16386 if (!SWIG_IsOK(ecode3)) {
16387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16388 }
16389 arg3 = static_cast< byte >(val3);
16390 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16391 if (!SWIG_IsOK(ecode4)) {
16392 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16393 }
16394 arg4 = static_cast< byte >(val4);
16395 {
16396 PyThreadState* __tstate = wxPyBeginAllowThreads();
16397 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16398 wxPyEndAllowThreads(__tstate);
16399 if (PyErr_Occurred()) SWIG_fail;
16400 }
16401 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16402 return resultobj;
16403 fail:
16404 return NULL;
16405 }
16406
16407
16408 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16409 PyObject *resultobj = 0;
16410 wxImage *arg1 = (wxImage *) 0 ;
16411 wxString *arg2 = 0 ;
16412 wxString *arg3 = 0 ;
16413 void *argp1 = 0 ;
16414 int res1 = 0 ;
16415 bool temp2 = false ;
16416 bool temp3 = false ;
16417 PyObject * obj0 = 0 ;
16418 PyObject * obj1 = 0 ;
16419 PyObject * obj2 = 0 ;
16420 char * kwnames[] = {
16421 (char *) "self",(char *) "name",(char *) "value", NULL
16422 };
16423
16424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16426 if (!SWIG_IsOK(res1)) {
16427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16428 }
16429 arg1 = reinterpret_cast< wxImage * >(argp1);
16430 {
16431 arg2 = wxString_in_helper(obj1);
16432 if (arg2 == NULL) SWIG_fail;
16433 temp2 = true;
16434 }
16435 {
16436 arg3 = wxString_in_helper(obj2);
16437 if (arg3 == NULL) SWIG_fail;
16438 temp3 = true;
16439 }
16440 {
16441 PyThreadState* __tstate = wxPyBeginAllowThreads();
16442 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16443 wxPyEndAllowThreads(__tstate);
16444 if (PyErr_Occurred()) SWIG_fail;
16445 }
16446 resultobj = SWIG_Py_Void();
16447 {
16448 if (temp2)
16449 delete arg2;
16450 }
16451 {
16452 if (temp3)
16453 delete arg3;
16454 }
16455 return resultobj;
16456 fail:
16457 {
16458 if (temp2)
16459 delete arg2;
16460 }
16461 {
16462 if (temp3)
16463 delete arg3;
16464 }
16465 return NULL;
16466 }
16467
16468
16469 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16470 PyObject *resultobj = 0;
16471 wxImage *arg1 = (wxImage *) 0 ;
16472 wxString *arg2 = 0 ;
16473 int arg3 ;
16474 void *argp1 = 0 ;
16475 int res1 = 0 ;
16476 bool temp2 = false ;
16477 int val3 ;
16478 int ecode3 = 0 ;
16479 PyObject * obj0 = 0 ;
16480 PyObject * obj1 = 0 ;
16481 PyObject * obj2 = 0 ;
16482 char * kwnames[] = {
16483 (char *) "self",(char *) "name",(char *) "value", NULL
16484 };
16485
16486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16488 if (!SWIG_IsOK(res1)) {
16489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16490 }
16491 arg1 = reinterpret_cast< wxImage * >(argp1);
16492 {
16493 arg2 = wxString_in_helper(obj1);
16494 if (arg2 == NULL) SWIG_fail;
16495 temp2 = true;
16496 }
16497 ecode3 = SWIG_AsVal_int(obj2, &val3);
16498 if (!SWIG_IsOK(ecode3)) {
16499 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16500 }
16501 arg3 = static_cast< int >(val3);
16502 {
16503 PyThreadState* __tstate = wxPyBeginAllowThreads();
16504 (arg1)->SetOption((wxString const &)*arg2,arg3);
16505 wxPyEndAllowThreads(__tstate);
16506 if (PyErr_Occurred()) SWIG_fail;
16507 }
16508 resultobj = SWIG_Py_Void();
16509 {
16510 if (temp2)
16511 delete arg2;
16512 }
16513 return resultobj;
16514 fail:
16515 {
16516 if (temp2)
16517 delete arg2;
16518 }
16519 return NULL;
16520 }
16521
16522
16523 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16524 PyObject *resultobj = 0;
16525 wxImage *arg1 = (wxImage *) 0 ;
16526 wxString *arg2 = 0 ;
16527 wxString result;
16528 void *argp1 = 0 ;
16529 int res1 = 0 ;
16530 bool temp2 = false ;
16531 PyObject * obj0 = 0 ;
16532 PyObject * obj1 = 0 ;
16533 char * kwnames[] = {
16534 (char *) "self",(char *) "name", NULL
16535 };
16536
16537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16539 if (!SWIG_IsOK(res1)) {
16540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16541 }
16542 arg1 = reinterpret_cast< wxImage * >(argp1);
16543 {
16544 arg2 = wxString_in_helper(obj1);
16545 if (arg2 == NULL) SWIG_fail;
16546 temp2 = true;
16547 }
16548 {
16549 PyThreadState* __tstate = wxPyBeginAllowThreads();
16550 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16551 wxPyEndAllowThreads(__tstate);
16552 if (PyErr_Occurred()) SWIG_fail;
16553 }
16554 {
16555 #if wxUSE_UNICODE
16556 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16557 #else
16558 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16559 #endif
16560 }
16561 {
16562 if (temp2)
16563 delete arg2;
16564 }
16565 return resultobj;
16566 fail:
16567 {
16568 if (temp2)
16569 delete arg2;
16570 }
16571 return NULL;
16572 }
16573
16574
16575 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16576 PyObject *resultobj = 0;
16577 wxImage *arg1 = (wxImage *) 0 ;
16578 wxString *arg2 = 0 ;
16579 int result;
16580 void *argp1 = 0 ;
16581 int res1 = 0 ;
16582 bool temp2 = false ;
16583 PyObject * obj0 = 0 ;
16584 PyObject * obj1 = 0 ;
16585 char * kwnames[] = {
16586 (char *) "self",(char *) "name", NULL
16587 };
16588
16589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16591 if (!SWIG_IsOK(res1)) {
16592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16593 }
16594 arg1 = reinterpret_cast< wxImage * >(argp1);
16595 {
16596 arg2 = wxString_in_helper(obj1);
16597 if (arg2 == NULL) SWIG_fail;
16598 temp2 = true;
16599 }
16600 {
16601 PyThreadState* __tstate = wxPyBeginAllowThreads();
16602 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16603 wxPyEndAllowThreads(__tstate);
16604 if (PyErr_Occurred()) SWIG_fail;
16605 }
16606 resultobj = SWIG_From_int(static_cast< int >(result));
16607 {
16608 if (temp2)
16609 delete arg2;
16610 }
16611 return resultobj;
16612 fail:
16613 {
16614 if (temp2)
16615 delete arg2;
16616 }
16617 return NULL;
16618 }
16619
16620
16621 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16622 PyObject *resultobj = 0;
16623 wxImage *arg1 = (wxImage *) 0 ;
16624 wxString *arg2 = 0 ;
16625 bool result;
16626 void *argp1 = 0 ;
16627 int res1 = 0 ;
16628 bool temp2 = false ;
16629 PyObject * obj0 = 0 ;
16630 PyObject * obj1 = 0 ;
16631 char * kwnames[] = {
16632 (char *) "self",(char *) "name", NULL
16633 };
16634
16635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16637 if (!SWIG_IsOK(res1)) {
16638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16639 }
16640 arg1 = reinterpret_cast< wxImage * >(argp1);
16641 {
16642 arg2 = wxString_in_helper(obj1);
16643 if (arg2 == NULL) SWIG_fail;
16644 temp2 = true;
16645 }
16646 {
16647 PyThreadState* __tstate = wxPyBeginAllowThreads();
16648 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16649 wxPyEndAllowThreads(__tstate);
16650 if (PyErr_Occurred()) SWIG_fail;
16651 }
16652 {
16653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16654 }
16655 {
16656 if (temp2)
16657 delete arg2;
16658 }
16659 return resultobj;
16660 fail:
16661 {
16662 if (temp2)
16663 delete arg2;
16664 }
16665 return NULL;
16666 }
16667
16668
16669 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16670 PyObject *resultobj = 0;
16671 wxImage *arg1 = (wxImage *) 0 ;
16672 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16673 unsigned long result;
16674 void *argp1 = 0 ;
16675 int res1 = 0 ;
16676 unsigned long val2 ;
16677 int ecode2 = 0 ;
16678 PyObject * obj0 = 0 ;
16679 PyObject * obj1 = 0 ;
16680 char * kwnames[] = {
16681 (char *) "self",(char *) "stopafter", NULL
16682 };
16683
16684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16686 if (!SWIG_IsOK(res1)) {
16687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16688 }
16689 arg1 = reinterpret_cast< wxImage * >(argp1);
16690 if (obj1) {
16691 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16692 if (!SWIG_IsOK(ecode2)) {
16693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16694 }
16695 arg2 = static_cast< unsigned long >(val2);
16696 }
16697 {
16698 PyThreadState* __tstate = wxPyBeginAllowThreads();
16699 result = (unsigned long)(arg1)->CountColours(arg2);
16700 wxPyEndAllowThreads(__tstate);
16701 if (PyErr_Occurred()) SWIG_fail;
16702 }
16703 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16704 return resultobj;
16705 fail:
16706 return NULL;
16707 }
16708
16709
16710 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16711 PyObject *resultobj = 0;
16712 wxImage *arg1 = (wxImage *) 0 ;
16713 wxImageHistogram *arg2 = 0 ;
16714 unsigned long result;
16715 void *argp1 = 0 ;
16716 int res1 = 0 ;
16717 void *argp2 = 0 ;
16718 int res2 = 0 ;
16719 PyObject * obj0 = 0 ;
16720 PyObject * obj1 = 0 ;
16721 char * kwnames[] = {
16722 (char *) "self",(char *) "h", NULL
16723 };
16724
16725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16727 if (!SWIG_IsOK(res1)) {
16728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16729 }
16730 arg1 = reinterpret_cast< wxImage * >(argp1);
16731 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16732 if (!SWIG_IsOK(res2)) {
16733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16734 }
16735 if (!argp2) {
16736 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16737 }
16738 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16739 {
16740 PyThreadState* __tstate = wxPyBeginAllowThreads();
16741 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16742 wxPyEndAllowThreads(__tstate);
16743 if (PyErr_Occurred()) SWIG_fail;
16744 }
16745 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16746 return resultobj;
16747 fail:
16748 return NULL;
16749 }
16750
16751
16752 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16753 PyObject *resultobj = 0;
16754 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16755 void *argp1 = 0 ;
16756 int res1 = 0 ;
16757 PyObject * obj0 = 0 ;
16758 char * kwnames[] = {
16759 (char *) "handler", NULL
16760 };
16761
16762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16764 if (!SWIG_IsOK(res1)) {
16765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16766 }
16767 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 wxImage::AddHandler(arg1);
16771 wxPyEndAllowThreads(__tstate);
16772 if (PyErr_Occurred()) SWIG_fail;
16773 }
16774 resultobj = SWIG_Py_Void();
16775 return resultobj;
16776 fail:
16777 return NULL;
16778 }
16779
16780
16781 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16782 PyObject *resultobj = 0;
16783 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16784 void *argp1 = 0 ;
16785 int res1 = 0 ;
16786 PyObject * obj0 = 0 ;
16787 char * kwnames[] = {
16788 (char *) "handler", NULL
16789 };
16790
16791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16793 if (!SWIG_IsOK(res1)) {
16794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16795 }
16796 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16797 {
16798 PyThreadState* __tstate = wxPyBeginAllowThreads();
16799 wxImage::InsertHandler(arg1);
16800 wxPyEndAllowThreads(__tstate);
16801 if (PyErr_Occurred()) SWIG_fail;
16802 }
16803 resultobj = SWIG_Py_Void();
16804 return resultobj;
16805 fail:
16806 return NULL;
16807 }
16808
16809
16810 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16811 PyObject *resultobj = 0;
16812 wxString *arg1 = 0 ;
16813 bool result;
16814 bool temp1 = false ;
16815 PyObject * obj0 = 0 ;
16816 char * kwnames[] = {
16817 (char *) "name", NULL
16818 };
16819
16820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16821 {
16822 arg1 = wxString_in_helper(obj0);
16823 if (arg1 == NULL) SWIG_fail;
16824 temp1 = true;
16825 }
16826 {
16827 PyThreadState* __tstate = wxPyBeginAllowThreads();
16828 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16829 wxPyEndAllowThreads(__tstate);
16830 if (PyErr_Occurred()) SWIG_fail;
16831 }
16832 {
16833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16834 }
16835 {
16836 if (temp1)
16837 delete arg1;
16838 }
16839 return resultobj;
16840 fail:
16841 {
16842 if (temp1)
16843 delete arg1;
16844 }
16845 return NULL;
16846 }
16847
16848
16849 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16850 PyObject *resultobj = 0;
16851 PyObject *result = 0 ;
16852
16853 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16854 {
16855 PyThreadState* __tstate = wxPyBeginAllowThreads();
16856 result = (PyObject *)wxImage_GetHandlers();
16857 wxPyEndAllowThreads(__tstate);
16858 if (PyErr_Occurred()) SWIG_fail;
16859 }
16860 resultobj = result;
16861 return resultobj;
16862 fail:
16863 return NULL;
16864 }
16865
16866
16867 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16868 PyObject *resultobj = 0;
16869 wxString result;
16870
16871 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16872 {
16873 PyThreadState* __tstate = wxPyBeginAllowThreads();
16874 result = wxImage::GetImageExtWildcard();
16875 wxPyEndAllowThreads(__tstate);
16876 if (PyErr_Occurred()) SWIG_fail;
16877 }
16878 {
16879 #if wxUSE_UNICODE
16880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16881 #else
16882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16883 #endif
16884 }
16885 return resultobj;
16886 fail:
16887 return NULL;
16888 }
16889
16890
16891 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16892 PyObject *resultobj = 0;
16893 wxImage *arg1 = (wxImage *) 0 ;
16894 int arg2 = (int) -1 ;
16895 wxBitmap result;
16896 void *argp1 = 0 ;
16897 int res1 = 0 ;
16898 int val2 ;
16899 int ecode2 = 0 ;
16900 PyObject * obj0 = 0 ;
16901 PyObject * obj1 = 0 ;
16902 char * kwnames[] = {
16903 (char *) "self",(char *) "depth", NULL
16904 };
16905
16906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16908 if (!SWIG_IsOK(res1)) {
16909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16910 }
16911 arg1 = reinterpret_cast< wxImage * >(argp1);
16912 if (obj1) {
16913 ecode2 = SWIG_AsVal_int(obj1, &val2);
16914 if (!SWIG_IsOK(ecode2)) {
16915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16916 }
16917 arg2 = static_cast< int >(val2);
16918 }
16919 {
16920 if (!wxPyCheckForApp()) SWIG_fail;
16921 PyThreadState* __tstate = wxPyBeginAllowThreads();
16922 result = wxImage_ConvertToBitmap(arg1,arg2);
16923 wxPyEndAllowThreads(__tstate);
16924 if (PyErr_Occurred()) SWIG_fail;
16925 }
16926 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16927 return resultobj;
16928 fail:
16929 return NULL;
16930 }
16931
16932
16933 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16934 PyObject *resultobj = 0;
16935 wxImage *arg1 = (wxImage *) 0 ;
16936 byte arg2 ;
16937 byte arg3 ;
16938 byte arg4 ;
16939 wxBitmap result;
16940 void *argp1 = 0 ;
16941 int res1 = 0 ;
16942 unsigned char val2 ;
16943 int ecode2 = 0 ;
16944 unsigned char val3 ;
16945 int ecode3 = 0 ;
16946 unsigned char val4 ;
16947 int ecode4 = 0 ;
16948 PyObject * obj0 = 0 ;
16949 PyObject * obj1 = 0 ;
16950 PyObject * obj2 = 0 ;
16951 PyObject * obj3 = 0 ;
16952 char * kwnames[] = {
16953 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16954 };
16955
16956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16958 if (!SWIG_IsOK(res1)) {
16959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16960 }
16961 arg1 = reinterpret_cast< wxImage * >(argp1);
16962 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16963 if (!SWIG_IsOK(ecode2)) {
16964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16965 }
16966 arg2 = static_cast< byte >(val2);
16967 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16968 if (!SWIG_IsOK(ecode3)) {
16969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16970 }
16971 arg3 = static_cast< byte >(val3);
16972 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16973 if (!SWIG_IsOK(ecode4)) {
16974 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16975 }
16976 arg4 = static_cast< byte >(val4);
16977 {
16978 if (!wxPyCheckForApp()) SWIG_fail;
16979 PyThreadState* __tstate = wxPyBeginAllowThreads();
16980 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16981 wxPyEndAllowThreads(__tstate);
16982 if (PyErr_Occurred()) SWIG_fail;
16983 }
16984 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16985 return resultobj;
16986 fail:
16987 return NULL;
16988 }
16989
16990
16991 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16992 PyObject *resultobj = 0;
16993 wxImage *arg1 = (wxImage *) 0 ;
16994 double arg2 ;
16995 void *argp1 = 0 ;
16996 int res1 = 0 ;
16997 double val2 ;
16998 int ecode2 = 0 ;
16999 PyObject * obj0 = 0 ;
17000 PyObject * obj1 = 0 ;
17001 char * kwnames[] = {
17002 (char *) "self",(char *) "angle", NULL
17003 };
17004
17005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
17006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17007 if (!SWIG_IsOK(res1)) {
17008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
17009 }
17010 arg1 = reinterpret_cast< wxImage * >(argp1);
17011 ecode2 = SWIG_AsVal_double(obj1, &val2);
17012 if (!SWIG_IsOK(ecode2)) {
17013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
17014 }
17015 arg2 = static_cast< double >(val2);
17016 {
17017 PyThreadState* __tstate = wxPyBeginAllowThreads();
17018 (arg1)->RotateHue(arg2);
17019 wxPyEndAllowThreads(__tstate);
17020 if (PyErr_Occurred()) SWIG_fail;
17021 }
17022 resultobj = SWIG_Py_Void();
17023 return resultobj;
17024 fail:
17025 return NULL;
17026 }
17027
17028
17029 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17030 PyObject *resultobj = 0;
17031 wxImage_RGBValue arg1 ;
17032 wxImage_HSVValue result;
17033 void *argp1 ;
17034 int res1 = 0 ;
17035 PyObject * obj0 = 0 ;
17036 char * kwnames[] = {
17037 (char *) "rgb", NULL
17038 };
17039
17040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
17041 {
17042 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
17043 if (!SWIG_IsOK(res1)) {
17044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17045 }
17046 if (!argp1) {
17047 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
17048 } else {
17049 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
17050 arg1 = *temp;
17051 if (SWIG_IsNewObj(res1)) delete temp;
17052 }
17053 }
17054 {
17055 PyThreadState* __tstate = wxPyBeginAllowThreads();
17056 result = wxImage::RGBtoHSV(arg1);
17057 wxPyEndAllowThreads(__tstate);
17058 if (PyErr_Occurred()) SWIG_fail;
17059 }
17060 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
17061 return resultobj;
17062 fail:
17063 return NULL;
17064 }
17065
17066
17067 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17068 PyObject *resultobj = 0;
17069 wxImage_HSVValue arg1 ;
17070 wxImage_RGBValue result;
17071 void *argp1 ;
17072 int res1 = 0 ;
17073 PyObject * obj0 = 0 ;
17074 char * kwnames[] = {
17075 (char *) "hsv", NULL
17076 };
17077
17078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
17079 {
17080 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
17081 if (!SWIG_IsOK(res1)) {
17082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17083 }
17084 if (!argp1) {
17085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
17086 } else {
17087 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
17088 arg1 = *temp;
17089 if (SWIG_IsNewObj(res1)) delete temp;
17090 }
17091 }
17092 {
17093 PyThreadState* __tstate = wxPyBeginAllowThreads();
17094 result = wxImage::HSVtoRGB(arg1);
17095 wxPyEndAllowThreads(__tstate);
17096 if (PyErr_Occurred()) SWIG_fail;
17097 }
17098 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
17099 return resultobj;
17100 fail:
17101 return NULL;
17102 }
17103
17104
17105 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17106 PyObject *obj;
17107 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17108 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
17109 return SWIG_Py_Void();
17110 }
17111
17112 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17113 return SWIG_Python_InitShadowInstance(args);
17114 }
17115
17116 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17117 PyObject *resultobj = 0;
17118 int arg1 ;
17119 int arg2 ;
17120 buffer arg3 ;
17121 int arg4 ;
17122 buffer arg5 = (buffer) NULL ;
17123 int arg6 = (int) 0 ;
17124 wxImage *result = 0 ;
17125 int val1 ;
17126 int ecode1 = 0 ;
17127 int val2 ;
17128 int ecode2 = 0 ;
17129 Py_ssize_t temp3 ;
17130 Py_ssize_t temp5 ;
17131 PyObject * obj0 = 0 ;
17132 PyObject * obj1 = 0 ;
17133 PyObject * obj2 = 0 ;
17134 PyObject * obj3 = 0 ;
17135 char * kwnames[] = {
17136 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
17137 };
17138
17139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17140 ecode1 = SWIG_AsVal_int(obj0, &val1);
17141 if (!SWIG_IsOK(ecode1)) {
17142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
17143 }
17144 arg1 = static_cast< int >(val1);
17145 ecode2 = SWIG_AsVal_int(obj1, &val2);
17146 if (!SWIG_IsOK(ecode2)) {
17147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
17148 }
17149 arg2 = static_cast< int >(val2);
17150 {
17151 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
17152 arg4 = (int)temp3;
17153 }
17154 if (obj3) {
17155 {
17156 if (obj3 != Py_None) {
17157 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
17158 arg6 = (int)temp5;
17159 }
17160 }
17161 }
17162 {
17163 PyThreadState* __tstate = wxPyBeginAllowThreads();
17164 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
17165 wxPyEndAllowThreads(__tstate);
17166 if (PyErr_Occurred()) SWIG_fail;
17167 }
17168 {
17169 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
17170 }
17171 return resultobj;
17172 fail:
17173 return NULL;
17174 }
17175
17176
17177 SWIGINTERN int NullImage_set(PyObject *) {
17178 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
17179 return 1;
17180 }
17181
17182
17183 SWIGINTERN PyObject *NullImage_get(void) {
17184 PyObject *pyobj = 0;
17185
17186 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
17187 return pyobj;
17188 }
17189
17190
17191 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
17192 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
17193 return 1;
17194 }
17195
17196
17197 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17198 PyObject *pyobj = 0;
17199
17200 {
17201 #if wxUSE_UNICODE
17202 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17203 #else
17204 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17205 #endif
17206 }
17207 return pyobj;
17208 }
17209
17210
17211 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17212 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17213 return 1;
17214 }
17215
17216
17217 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17218 PyObject *pyobj = 0;
17219
17220 {
17221 #if wxUSE_UNICODE
17222 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17223 #else
17224 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17225 #endif
17226 }
17227 return pyobj;
17228 }
17229
17230
17231 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17232 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17233 return 1;
17234 }
17235
17236
17237 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17238 PyObject *pyobj = 0;
17239
17240 {
17241 #if wxUSE_UNICODE
17242 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17243 #else
17244 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17245 #endif
17246 }
17247 return pyobj;
17248 }
17249
17250
17251 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17252 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17253 return 1;
17254 }
17255
17256
17257 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17258 PyObject *pyobj = 0;
17259
17260 {
17261 #if wxUSE_UNICODE
17262 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17263 #else
17264 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17265 #endif
17266 }
17267 return pyobj;
17268 }
17269
17270
17271 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17272 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17273 return 1;
17274 }
17275
17276
17277 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17278 PyObject *pyobj = 0;
17279
17280 {
17281 #if wxUSE_UNICODE
17282 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17283 #else
17284 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17285 #endif
17286 }
17287 return pyobj;
17288 }
17289
17290
17291 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17292 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17293 return 1;
17294 }
17295
17296
17297 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17298 PyObject *pyobj = 0;
17299
17300 {
17301 #if wxUSE_UNICODE
17302 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17303 #else
17304 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17305 #endif
17306 }
17307 return pyobj;
17308 }
17309
17310
17311 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17312 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17313 return 1;
17314 }
17315
17316
17317 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17318 PyObject *pyobj = 0;
17319
17320 {
17321 #if wxUSE_UNICODE
17322 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17323 #else
17324 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17325 #endif
17326 }
17327 return pyobj;
17328 }
17329
17330
17331 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17332 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17333 return 1;
17334 }
17335
17336
17337 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17338 PyObject *pyobj = 0;
17339
17340 {
17341 #if wxUSE_UNICODE
17342 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17343 #else
17344 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17345 #endif
17346 }
17347 return pyobj;
17348 }
17349
17350
17351 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17352 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17353 return 1;
17354 }
17355
17356
17357 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17358 PyObject *pyobj = 0;
17359
17360 {
17361 #if wxUSE_UNICODE
17362 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17363 #else
17364 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17365 #endif
17366 }
17367 return pyobj;
17368 }
17369
17370
17371 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17372 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17373 return 1;
17374 }
17375
17376
17377 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17378 PyObject *pyobj = 0;
17379
17380 {
17381 #if wxUSE_UNICODE
17382 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17383 #else
17384 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17385 #endif
17386 }
17387 return pyobj;
17388 }
17389
17390
17391 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17392 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17393 return 1;
17394 }
17395
17396
17397 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17398 PyObject *pyobj = 0;
17399
17400 {
17401 #if wxUSE_UNICODE
17402 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17403 #else
17404 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17405 #endif
17406 }
17407 return pyobj;
17408 }
17409
17410
17411 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17412 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17413 return 1;
17414 }
17415
17416
17417 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17418 PyObject *pyobj = 0;
17419
17420 {
17421 #if wxUSE_UNICODE
17422 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17423 #else
17424 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17425 #endif
17426 }
17427 return pyobj;
17428 }
17429
17430
17431 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17432 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17433 return 1;
17434 }
17435
17436
17437 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17438 PyObject *pyobj = 0;
17439
17440 {
17441 #if wxUSE_UNICODE
17442 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17443 #else
17444 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17445 #endif
17446 }
17447 return pyobj;
17448 }
17449
17450
17451 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17452 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17453 return 1;
17454 }
17455
17456
17457 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17458 PyObject *pyobj = 0;
17459
17460 {
17461 #if wxUSE_UNICODE
17462 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17463 #else
17464 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17465 #endif
17466 }
17467 return pyobj;
17468 }
17469
17470
17471 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17472 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17473 return 1;
17474 }
17475
17476
17477 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17478 PyObject *pyobj = 0;
17479
17480 {
17481 #if wxUSE_UNICODE
17482 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17483 #else
17484 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17485 #endif
17486 }
17487 return pyobj;
17488 }
17489
17490
17491 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17492 PyObject *resultobj = 0;
17493 wxBMPHandler *result = 0 ;
17494
17495 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17496 {
17497 PyThreadState* __tstate = wxPyBeginAllowThreads();
17498 result = (wxBMPHandler *)new wxBMPHandler();
17499 wxPyEndAllowThreads(__tstate);
17500 if (PyErr_Occurred()) SWIG_fail;
17501 }
17502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17503 return resultobj;
17504 fail:
17505 return NULL;
17506 }
17507
17508
17509 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17510 PyObject *obj;
17511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17512 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17513 return SWIG_Py_Void();
17514 }
17515
17516 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17517 return SWIG_Python_InitShadowInstance(args);
17518 }
17519
17520 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17521 PyObject *resultobj = 0;
17522 wxICOHandler *result = 0 ;
17523
17524 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 result = (wxICOHandler *)new wxICOHandler();
17528 wxPyEndAllowThreads(__tstate);
17529 if (PyErr_Occurred()) SWIG_fail;
17530 }
17531 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17532 return resultobj;
17533 fail:
17534 return NULL;
17535 }
17536
17537
17538 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17539 PyObject *obj;
17540 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17541 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17542 return SWIG_Py_Void();
17543 }
17544
17545 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17546 return SWIG_Python_InitShadowInstance(args);
17547 }
17548
17549 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17550 PyObject *resultobj = 0;
17551 wxCURHandler *result = 0 ;
17552
17553 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17554 {
17555 PyThreadState* __tstate = wxPyBeginAllowThreads();
17556 result = (wxCURHandler *)new wxCURHandler();
17557 wxPyEndAllowThreads(__tstate);
17558 if (PyErr_Occurred()) SWIG_fail;
17559 }
17560 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17561 return resultobj;
17562 fail:
17563 return NULL;
17564 }
17565
17566
17567 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17568 PyObject *obj;
17569 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17570 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17571 return SWIG_Py_Void();
17572 }
17573
17574 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17575 return SWIG_Python_InitShadowInstance(args);
17576 }
17577
17578 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17579 PyObject *resultobj = 0;
17580 wxANIHandler *result = 0 ;
17581
17582 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17583 {
17584 PyThreadState* __tstate = wxPyBeginAllowThreads();
17585 result = (wxANIHandler *)new wxANIHandler();
17586 wxPyEndAllowThreads(__tstate);
17587 if (PyErr_Occurred()) SWIG_fail;
17588 }
17589 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17590 return resultobj;
17591 fail:
17592 return NULL;
17593 }
17594
17595
17596 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17597 PyObject *obj;
17598 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17599 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17600 return SWIG_Py_Void();
17601 }
17602
17603 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17604 return SWIG_Python_InitShadowInstance(args);
17605 }
17606
17607 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17608 PyObject *resultobj = 0;
17609 wxPNGHandler *result = 0 ;
17610
17611 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17612 {
17613 PyThreadState* __tstate = wxPyBeginAllowThreads();
17614 result = (wxPNGHandler *)new wxPNGHandler();
17615 wxPyEndAllowThreads(__tstate);
17616 if (PyErr_Occurred()) SWIG_fail;
17617 }
17618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17619 return resultobj;
17620 fail:
17621 return NULL;
17622 }
17623
17624
17625 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17626 PyObject *obj;
17627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17628 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17629 return SWIG_Py_Void();
17630 }
17631
17632 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17633 return SWIG_Python_InitShadowInstance(args);
17634 }
17635
17636 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17637 PyObject *resultobj = 0;
17638 wxGIFHandler *result = 0 ;
17639
17640 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17641 {
17642 PyThreadState* __tstate = wxPyBeginAllowThreads();
17643 result = (wxGIFHandler *)new wxGIFHandler();
17644 wxPyEndAllowThreads(__tstate);
17645 if (PyErr_Occurred()) SWIG_fail;
17646 }
17647 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17648 return resultobj;
17649 fail:
17650 return NULL;
17651 }
17652
17653
17654 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17655 PyObject *obj;
17656 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17657 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17658 return SWIG_Py_Void();
17659 }
17660
17661 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17662 return SWIG_Python_InitShadowInstance(args);
17663 }
17664
17665 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17666 PyObject *resultobj = 0;
17667 wxPCXHandler *result = 0 ;
17668
17669 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17670 {
17671 PyThreadState* __tstate = wxPyBeginAllowThreads();
17672 result = (wxPCXHandler *)new wxPCXHandler();
17673 wxPyEndAllowThreads(__tstate);
17674 if (PyErr_Occurred()) SWIG_fail;
17675 }
17676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17677 return resultobj;
17678 fail:
17679 return NULL;
17680 }
17681
17682
17683 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17684 PyObject *obj;
17685 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17686 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17687 return SWIG_Py_Void();
17688 }
17689
17690 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17691 return SWIG_Python_InitShadowInstance(args);
17692 }
17693
17694 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17695 PyObject *resultobj = 0;
17696 wxJPEGHandler *result = 0 ;
17697
17698 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17699 {
17700 PyThreadState* __tstate = wxPyBeginAllowThreads();
17701 result = (wxJPEGHandler *)new wxJPEGHandler();
17702 wxPyEndAllowThreads(__tstate);
17703 if (PyErr_Occurred()) SWIG_fail;
17704 }
17705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17713 PyObject *obj;
17714 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17715 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17716 return SWIG_Py_Void();
17717 }
17718
17719 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17720 return SWIG_Python_InitShadowInstance(args);
17721 }
17722
17723 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17724 PyObject *resultobj = 0;
17725 wxPNMHandler *result = 0 ;
17726
17727 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17728 {
17729 PyThreadState* __tstate = wxPyBeginAllowThreads();
17730 result = (wxPNMHandler *)new wxPNMHandler();
17731 wxPyEndAllowThreads(__tstate);
17732 if (PyErr_Occurred()) SWIG_fail;
17733 }
17734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17735 return resultobj;
17736 fail:
17737 return NULL;
17738 }
17739
17740
17741 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17742 PyObject *obj;
17743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17744 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17745 return SWIG_Py_Void();
17746 }
17747
17748 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17749 return SWIG_Python_InitShadowInstance(args);
17750 }
17751
17752 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17753 PyObject *resultobj = 0;
17754 wxXPMHandler *result = 0 ;
17755
17756 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17757 {
17758 PyThreadState* __tstate = wxPyBeginAllowThreads();
17759 result = (wxXPMHandler *)new wxXPMHandler();
17760 wxPyEndAllowThreads(__tstate);
17761 if (PyErr_Occurred()) SWIG_fail;
17762 }
17763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17764 return resultobj;
17765 fail:
17766 return NULL;
17767 }
17768
17769
17770 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17771 PyObject *obj;
17772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17773 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17774 return SWIG_Py_Void();
17775 }
17776
17777 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17778 return SWIG_Python_InitShadowInstance(args);
17779 }
17780
17781 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17782 PyObject *resultobj = 0;
17783 wxTIFFHandler *result = 0 ;
17784
17785 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17786 {
17787 PyThreadState* __tstate = wxPyBeginAllowThreads();
17788 result = (wxTIFFHandler *)new wxTIFFHandler();
17789 wxPyEndAllowThreads(__tstate);
17790 if (PyErr_Occurred()) SWIG_fail;
17791 }
17792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17793 return resultobj;
17794 fail:
17795 return NULL;
17796 }
17797
17798
17799 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17800 PyObject *obj;
17801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17802 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17803 return SWIG_Py_Void();
17804 }
17805
17806 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17807 return SWIG_Python_InitShadowInstance(args);
17808 }
17809
17810 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17811 PyObject *resultobj = 0;
17812 wxImage *arg1 = 0 ;
17813 wxImage *arg2 = 0 ;
17814 int arg3 = (int) 236 ;
17815 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17816 bool result;
17817 void *argp1 = 0 ;
17818 int res1 = 0 ;
17819 void *argp2 = 0 ;
17820 int res2 = 0 ;
17821 int val3 ;
17822 int ecode3 = 0 ;
17823 int val4 ;
17824 int ecode4 = 0 ;
17825 PyObject * obj0 = 0 ;
17826 PyObject * obj1 = 0 ;
17827 PyObject * obj2 = 0 ;
17828 PyObject * obj3 = 0 ;
17829 char * kwnames[] = {
17830 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17831 };
17832
17833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17834 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17835 if (!SWIG_IsOK(res1)) {
17836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17837 }
17838 if (!argp1) {
17839 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17840 }
17841 arg1 = reinterpret_cast< wxImage * >(argp1);
17842 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17843 if (!SWIG_IsOK(res2)) {
17844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17845 }
17846 if (!argp2) {
17847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17848 }
17849 arg2 = reinterpret_cast< wxImage * >(argp2);
17850 if (obj2) {
17851 ecode3 = SWIG_AsVal_int(obj2, &val3);
17852 if (!SWIG_IsOK(ecode3)) {
17853 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17854 }
17855 arg3 = static_cast< int >(val3);
17856 }
17857 if (obj3) {
17858 ecode4 = SWIG_AsVal_int(obj3, &val4);
17859 if (!SWIG_IsOK(ecode4)) {
17860 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17861 }
17862 arg4 = static_cast< int >(val4);
17863 }
17864 {
17865 PyThreadState* __tstate = wxPyBeginAllowThreads();
17866 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17867 wxPyEndAllowThreads(__tstate);
17868 if (PyErr_Occurred()) SWIG_fail;
17869 }
17870 {
17871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17872 }
17873 return resultobj;
17874 fail:
17875 return NULL;
17876 }
17877
17878
17879 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17880 PyObject *obj;
17881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17882 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17883 return SWIG_Py_Void();
17884 }
17885
17886 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17887 PyObject *resultobj = 0;
17888 wxEvtHandler *result = 0 ;
17889
17890 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17891 {
17892 PyThreadState* __tstate = wxPyBeginAllowThreads();
17893 result = (wxEvtHandler *)new wxEvtHandler();
17894 wxPyEndAllowThreads(__tstate);
17895 if (PyErr_Occurred()) SWIG_fail;
17896 }
17897 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17898 return resultobj;
17899 fail:
17900 return NULL;
17901 }
17902
17903
17904 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17905 PyObject *resultobj = 0;
17906 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17907 wxEvtHandler *result = 0 ;
17908 void *argp1 = 0 ;
17909 int res1 = 0 ;
17910 PyObject *swig_obj[1] ;
17911
17912 if (!args) SWIG_fail;
17913 swig_obj[0] = args;
17914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17915 if (!SWIG_IsOK(res1)) {
17916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17917 }
17918 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17919 {
17920 PyThreadState* __tstate = wxPyBeginAllowThreads();
17921 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17922 wxPyEndAllowThreads(__tstate);
17923 if (PyErr_Occurred()) SWIG_fail;
17924 }
17925 {
17926 resultobj = wxPyMake_wxObject(result, 0);
17927 }
17928 return resultobj;
17929 fail:
17930 return NULL;
17931 }
17932
17933
17934 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17935 PyObject *resultobj = 0;
17936 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17937 wxEvtHandler *result = 0 ;
17938 void *argp1 = 0 ;
17939 int res1 = 0 ;
17940 PyObject *swig_obj[1] ;
17941
17942 if (!args) SWIG_fail;
17943 swig_obj[0] = args;
17944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17945 if (!SWIG_IsOK(res1)) {
17946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17947 }
17948 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17949 {
17950 PyThreadState* __tstate = wxPyBeginAllowThreads();
17951 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17952 wxPyEndAllowThreads(__tstate);
17953 if (PyErr_Occurred()) SWIG_fail;
17954 }
17955 {
17956 resultobj = wxPyMake_wxObject(result, 0);
17957 }
17958 return resultobj;
17959 fail:
17960 return NULL;
17961 }
17962
17963
17964 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17965 PyObject *resultobj = 0;
17966 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17967 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17968 void *argp1 = 0 ;
17969 int res1 = 0 ;
17970 void *argp2 = 0 ;
17971 int res2 = 0 ;
17972 PyObject * obj0 = 0 ;
17973 PyObject * obj1 = 0 ;
17974 char * kwnames[] = {
17975 (char *) "self",(char *) "handler", NULL
17976 };
17977
17978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17980 if (!SWIG_IsOK(res1)) {
17981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17982 }
17983 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17985 if (!SWIG_IsOK(res2)) {
17986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17987 }
17988 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17989 {
17990 PyThreadState* __tstate = wxPyBeginAllowThreads();
17991 (arg1)->SetNextHandler(arg2);
17992 wxPyEndAllowThreads(__tstate);
17993 if (PyErr_Occurred()) SWIG_fail;
17994 }
17995 resultobj = SWIG_Py_Void();
17996 return resultobj;
17997 fail:
17998 return NULL;
17999 }
18000
18001
18002 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18003 PyObject *resultobj = 0;
18004 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18005 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
18006 void *argp1 = 0 ;
18007 int res1 = 0 ;
18008 void *argp2 = 0 ;
18009 int res2 = 0 ;
18010 PyObject * obj0 = 0 ;
18011 PyObject * obj1 = 0 ;
18012 char * kwnames[] = {
18013 (char *) "self",(char *) "handler", NULL
18014 };
18015
18016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
18017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18018 if (!SWIG_IsOK(res1)) {
18019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18020 }
18021 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18022 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18023 if (!SWIG_IsOK(res2)) {
18024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
18025 }
18026 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
18027 {
18028 PyThreadState* __tstate = wxPyBeginAllowThreads();
18029 (arg1)->SetPreviousHandler(arg2);
18030 wxPyEndAllowThreads(__tstate);
18031 if (PyErr_Occurred()) SWIG_fail;
18032 }
18033 resultobj = SWIG_Py_Void();
18034 return resultobj;
18035 fail:
18036 return NULL;
18037 }
18038
18039
18040 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18041 PyObject *resultobj = 0;
18042 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18043 bool result;
18044 void *argp1 = 0 ;
18045 int res1 = 0 ;
18046 PyObject *swig_obj[1] ;
18047
18048 if (!args) SWIG_fail;
18049 swig_obj[0] = args;
18050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18051 if (!SWIG_IsOK(res1)) {
18052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18053 }
18054 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18055 {
18056 PyThreadState* __tstate = wxPyBeginAllowThreads();
18057 result = (bool)(arg1)->GetEvtHandlerEnabled();
18058 wxPyEndAllowThreads(__tstate);
18059 if (PyErr_Occurred()) SWIG_fail;
18060 }
18061 {
18062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18063 }
18064 return resultobj;
18065 fail:
18066 return NULL;
18067 }
18068
18069
18070 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18071 PyObject *resultobj = 0;
18072 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18073 bool arg2 ;
18074 void *argp1 = 0 ;
18075 int res1 = 0 ;
18076 bool val2 ;
18077 int ecode2 = 0 ;
18078 PyObject * obj0 = 0 ;
18079 PyObject * obj1 = 0 ;
18080 char * kwnames[] = {
18081 (char *) "self",(char *) "enabled", NULL
18082 };
18083
18084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
18085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18086 if (!SWIG_IsOK(res1)) {
18087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18088 }
18089 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18090 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18091 if (!SWIG_IsOK(ecode2)) {
18092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
18093 }
18094 arg2 = static_cast< bool >(val2);
18095 {
18096 PyThreadState* __tstate = wxPyBeginAllowThreads();
18097 (arg1)->SetEvtHandlerEnabled(arg2);
18098 wxPyEndAllowThreads(__tstate);
18099 if (PyErr_Occurred()) SWIG_fail;
18100 }
18101 resultobj = SWIG_Py_Void();
18102 return resultobj;
18103 fail:
18104 return NULL;
18105 }
18106
18107
18108 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18109 PyObject *resultobj = 0;
18110 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18111 wxEvent *arg2 = 0 ;
18112 bool result;
18113 void *argp1 = 0 ;
18114 int res1 = 0 ;
18115 void *argp2 = 0 ;
18116 int res2 = 0 ;
18117 PyObject * obj0 = 0 ;
18118 PyObject * obj1 = 0 ;
18119 char * kwnames[] = {
18120 (char *) "self",(char *) "event", NULL
18121 };
18122
18123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18125 if (!SWIG_IsOK(res1)) {
18126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18127 }
18128 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18129 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18130 if (!SWIG_IsOK(res2)) {
18131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18132 }
18133 if (!argp2) {
18134 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18135 }
18136 arg2 = reinterpret_cast< wxEvent * >(argp2);
18137 {
18138 PyThreadState* __tstate = wxPyBeginAllowThreads();
18139 result = (bool)(arg1)->ProcessEvent(*arg2);
18140 wxPyEndAllowThreads(__tstate);
18141 if (PyErr_Occurred()) SWIG_fail;
18142 }
18143 {
18144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18145 }
18146 return resultobj;
18147 fail:
18148 return NULL;
18149 }
18150
18151
18152 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18153 PyObject *resultobj = 0;
18154 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18155 wxEvent *arg2 = 0 ;
18156 void *argp1 = 0 ;
18157 int res1 = 0 ;
18158 void *argp2 = 0 ;
18159 int res2 = 0 ;
18160 PyObject * obj0 = 0 ;
18161 PyObject * obj1 = 0 ;
18162 char * kwnames[] = {
18163 (char *) "self",(char *) "event", NULL
18164 };
18165
18166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18168 if (!SWIG_IsOK(res1)) {
18169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18170 }
18171 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18172 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
18173 if (!SWIG_IsOK(res2)) {
18174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18175 }
18176 if (!argp2) {
18177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
18178 }
18179 arg2 = reinterpret_cast< wxEvent * >(argp2);
18180 {
18181 PyThreadState* __tstate = wxPyBeginAllowThreads();
18182 (arg1)->AddPendingEvent(*arg2);
18183 wxPyEndAllowThreads(__tstate);
18184 if (PyErr_Occurred()) SWIG_fail;
18185 }
18186 resultobj = SWIG_Py_Void();
18187 return resultobj;
18188 fail:
18189 return NULL;
18190 }
18191
18192
18193 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18194 PyObject *resultobj = 0;
18195 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18196 void *argp1 = 0 ;
18197 int res1 = 0 ;
18198 PyObject *swig_obj[1] ;
18199
18200 if (!args) SWIG_fail;
18201 swig_obj[0] = args;
18202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18203 if (!SWIG_IsOK(res1)) {
18204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18205 }
18206 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18207 {
18208 PyThreadState* __tstate = wxPyBeginAllowThreads();
18209 (arg1)->ProcessPendingEvents();
18210 wxPyEndAllowThreads(__tstate);
18211 if (PyErr_Occurred()) SWIG_fail;
18212 }
18213 resultobj = SWIG_Py_Void();
18214 return resultobj;
18215 fail:
18216 return NULL;
18217 }
18218
18219
18220 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18221 PyObject *resultobj = 0;
18222 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18223 int arg2 ;
18224 int arg3 ;
18225 int arg4 ;
18226 PyObject *arg5 = (PyObject *) 0 ;
18227 void *argp1 = 0 ;
18228 int res1 = 0 ;
18229 int val2 ;
18230 int ecode2 = 0 ;
18231 int val3 ;
18232 int ecode3 = 0 ;
18233 int val4 ;
18234 int ecode4 = 0 ;
18235 PyObject * obj0 = 0 ;
18236 PyObject * obj1 = 0 ;
18237 PyObject * obj2 = 0 ;
18238 PyObject * obj3 = 0 ;
18239 PyObject * obj4 = 0 ;
18240 char * kwnames[] = {
18241 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18242 };
18243
18244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18246 if (!SWIG_IsOK(res1)) {
18247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18248 }
18249 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18250 ecode2 = SWIG_AsVal_int(obj1, &val2);
18251 if (!SWIG_IsOK(ecode2)) {
18252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18253 }
18254 arg2 = static_cast< int >(val2);
18255 ecode3 = SWIG_AsVal_int(obj2, &val3);
18256 if (!SWIG_IsOK(ecode3)) {
18257 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18258 }
18259 arg3 = static_cast< int >(val3);
18260 ecode4 = SWIG_AsVal_int(obj3, &val4);
18261 if (!SWIG_IsOK(ecode4)) {
18262 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18263 }
18264 arg4 = static_cast< int >(val4);
18265 arg5 = obj4;
18266 {
18267 PyThreadState* __tstate = wxPyBeginAllowThreads();
18268 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18269 wxPyEndAllowThreads(__tstate);
18270 if (PyErr_Occurred()) SWIG_fail;
18271 }
18272 resultobj = SWIG_Py_Void();
18273 return resultobj;
18274 fail:
18275 return NULL;
18276 }
18277
18278
18279 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18280 PyObject *resultobj = 0;
18281 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18282 int arg2 ;
18283 int arg3 = (int) -1 ;
18284 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18285 bool result;
18286 void *argp1 = 0 ;
18287 int res1 = 0 ;
18288 int val2 ;
18289 int ecode2 = 0 ;
18290 int val3 ;
18291 int ecode3 = 0 ;
18292 int val4 ;
18293 int ecode4 = 0 ;
18294 PyObject * obj0 = 0 ;
18295 PyObject * obj1 = 0 ;
18296 PyObject * obj2 = 0 ;
18297 PyObject * obj3 = 0 ;
18298 char * kwnames[] = {
18299 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18300 };
18301
18302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18304 if (!SWIG_IsOK(res1)) {
18305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18306 }
18307 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18308 ecode2 = SWIG_AsVal_int(obj1, &val2);
18309 if (!SWIG_IsOK(ecode2)) {
18310 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18311 }
18312 arg2 = static_cast< int >(val2);
18313 if (obj2) {
18314 ecode3 = SWIG_AsVal_int(obj2, &val3);
18315 if (!SWIG_IsOK(ecode3)) {
18316 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18317 }
18318 arg3 = static_cast< int >(val3);
18319 }
18320 if (obj3) {
18321 ecode4 = SWIG_AsVal_int(obj3, &val4);
18322 if (!SWIG_IsOK(ecode4)) {
18323 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18324 }
18325 arg4 = static_cast< wxEventType >(val4);
18326 }
18327 {
18328 PyThreadState* __tstate = wxPyBeginAllowThreads();
18329 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18330 wxPyEndAllowThreads(__tstate);
18331 if (PyErr_Occurred()) SWIG_fail;
18332 }
18333 {
18334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18335 }
18336 return resultobj;
18337 fail:
18338 return NULL;
18339 }
18340
18341
18342 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18343 PyObject *resultobj = 0;
18344 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18345 PyObject *arg2 = (PyObject *) 0 ;
18346 bool arg3 = (bool) true ;
18347 void *argp1 = 0 ;
18348 int res1 = 0 ;
18349 bool val3 ;
18350 int ecode3 = 0 ;
18351 PyObject * obj0 = 0 ;
18352 PyObject * obj1 = 0 ;
18353 PyObject * obj2 = 0 ;
18354 char * kwnames[] = {
18355 (char *) "self",(char *) "_self",(char *) "incref", NULL
18356 };
18357
18358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18360 if (!SWIG_IsOK(res1)) {
18361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18362 }
18363 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18364 arg2 = obj1;
18365 if (obj2) {
18366 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18367 if (!SWIG_IsOK(ecode3)) {
18368 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18369 }
18370 arg3 = static_cast< bool >(val3);
18371 }
18372 {
18373 PyThreadState* __tstate = wxPyBeginAllowThreads();
18374 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18375 wxPyEndAllowThreads(__tstate);
18376 if (PyErr_Occurred()) SWIG_fail;
18377 }
18378 resultobj = SWIG_Py_Void();
18379 return resultobj;
18380 fail:
18381 return NULL;
18382 }
18383
18384
18385 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18386 PyObject *obj;
18387 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18388 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18389 return SWIG_Py_Void();
18390 }
18391
18392 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18393 return SWIG_Python_InitShadowInstance(args);
18394 }
18395
18396 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18397 PyObject *resultobj = 0;
18398 wxEventType result;
18399
18400 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18401 {
18402 PyThreadState* __tstate = wxPyBeginAllowThreads();
18403 result = (wxEventType)wxNewEventType();
18404 wxPyEndAllowThreads(__tstate);
18405 if (PyErr_Occurred()) SWIG_fail;
18406 }
18407 resultobj = SWIG_From_int(static_cast< int >(result));
18408 return resultobj;
18409 fail:
18410 return NULL;
18411 }
18412
18413
18414 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18415 PyObject *resultobj = 0;
18416 wxEvent *arg1 = (wxEvent *) 0 ;
18417 void *argp1 = 0 ;
18418 int res1 = 0 ;
18419 PyObject *swig_obj[1] ;
18420
18421 if (!args) SWIG_fail;
18422 swig_obj[0] = args;
18423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18424 if (!SWIG_IsOK(res1)) {
18425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18426 }
18427 arg1 = reinterpret_cast< wxEvent * >(argp1);
18428 {
18429 PyThreadState* __tstate = wxPyBeginAllowThreads();
18430 delete arg1;
18431
18432 wxPyEndAllowThreads(__tstate);
18433 if (PyErr_Occurred()) SWIG_fail;
18434 }
18435 resultobj = SWIG_Py_Void();
18436 return resultobj;
18437 fail:
18438 return NULL;
18439 }
18440
18441
18442 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18443 PyObject *resultobj = 0;
18444 wxEvent *arg1 = (wxEvent *) 0 ;
18445 wxEventType arg2 ;
18446 void *argp1 = 0 ;
18447 int res1 = 0 ;
18448 int val2 ;
18449 int ecode2 = 0 ;
18450 PyObject * obj0 = 0 ;
18451 PyObject * obj1 = 0 ;
18452 char * kwnames[] = {
18453 (char *) "self",(char *) "typ", NULL
18454 };
18455
18456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18458 if (!SWIG_IsOK(res1)) {
18459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18460 }
18461 arg1 = reinterpret_cast< wxEvent * >(argp1);
18462 ecode2 = SWIG_AsVal_int(obj1, &val2);
18463 if (!SWIG_IsOK(ecode2)) {
18464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18465 }
18466 arg2 = static_cast< wxEventType >(val2);
18467 {
18468 PyThreadState* __tstate = wxPyBeginAllowThreads();
18469 (arg1)->SetEventType(arg2);
18470 wxPyEndAllowThreads(__tstate);
18471 if (PyErr_Occurred()) SWIG_fail;
18472 }
18473 resultobj = SWIG_Py_Void();
18474 return resultobj;
18475 fail:
18476 return NULL;
18477 }
18478
18479
18480 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18481 PyObject *resultobj = 0;
18482 wxEvent *arg1 = (wxEvent *) 0 ;
18483 wxEventType result;
18484 void *argp1 = 0 ;
18485 int res1 = 0 ;
18486 PyObject *swig_obj[1] ;
18487
18488 if (!args) SWIG_fail;
18489 swig_obj[0] = args;
18490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18491 if (!SWIG_IsOK(res1)) {
18492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18493 }
18494 arg1 = reinterpret_cast< wxEvent * >(argp1);
18495 {
18496 PyThreadState* __tstate = wxPyBeginAllowThreads();
18497 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18498 wxPyEndAllowThreads(__tstate);
18499 if (PyErr_Occurred()) SWIG_fail;
18500 }
18501 resultobj = SWIG_From_int(static_cast< int >(result));
18502 return resultobj;
18503 fail:
18504 return NULL;
18505 }
18506
18507
18508 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18509 PyObject *resultobj = 0;
18510 wxEvent *arg1 = (wxEvent *) 0 ;
18511 wxObject *result = 0 ;
18512 void *argp1 = 0 ;
18513 int res1 = 0 ;
18514 PyObject *swig_obj[1] ;
18515
18516 if (!args) SWIG_fail;
18517 swig_obj[0] = args;
18518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18519 if (!SWIG_IsOK(res1)) {
18520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18521 }
18522 arg1 = reinterpret_cast< wxEvent * >(argp1);
18523 {
18524 PyThreadState* __tstate = wxPyBeginAllowThreads();
18525 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18526 wxPyEndAllowThreads(__tstate);
18527 if (PyErr_Occurred()) SWIG_fail;
18528 }
18529 {
18530 resultobj = wxPyMake_wxObject(result, (bool)0);
18531 }
18532 return resultobj;
18533 fail:
18534 return NULL;
18535 }
18536
18537
18538 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18539 PyObject *resultobj = 0;
18540 wxEvent *arg1 = (wxEvent *) 0 ;
18541 wxObject *arg2 = (wxObject *) 0 ;
18542 void *argp1 = 0 ;
18543 int res1 = 0 ;
18544 void *argp2 = 0 ;
18545 int res2 = 0 ;
18546 PyObject * obj0 = 0 ;
18547 PyObject * obj1 = 0 ;
18548 char * kwnames[] = {
18549 (char *) "self",(char *) "obj", NULL
18550 };
18551
18552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18554 if (!SWIG_IsOK(res1)) {
18555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18556 }
18557 arg1 = reinterpret_cast< wxEvent * >(argp1);
18558 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18559 if (!SWIG_IsOK(res2)) {
18560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18561 }
18562 arg2 = reinterpret_cast< wxObject * >(argp2);
18563 {
18564 PyThreadState* __tstate = wxPyBeginAllowThreads();
18565 (arg1)->SetEventObject(arg2);
18566 wxPyEndAllowThreads(__tstate);
18567 if (PyErr_Occurred()) SWIG_fail;
18568 }
18569 resultobj = SWIG_Py_Void();
18570 return resultobj;
18571 fail:
18572 return NULL;
18573 }
18574
18575
18576 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18577 PyObject *resultobj = 0;
18578 wxEvent *arg1 = (wxEvent *) 0 ;
18579 long result;
18580 void *argp1 = 0 ;
18581 int res1 = 0 ;
18582 PyObject *swig_obj[1] ;
18583
18584 if (!args) SWIG_fail;
18585 swig_obj[0] = args;
18586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18587 if (!SWIG_IsOK(res1)) {
18588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18589 }
18590 arg1 = reinterpret_cast< wxEvent * >(argp1);
18591 {
18592 PyThreadState* __tstate = wxPyBeginAllowThreads();
18593 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18594 wxPyEndAllowThreads(__tstate);
18595 if (PyErr_Occurred()) SWIG_fail;
18596 }
18597 resultobj = SWIG_From_long(static_cast< long >(result));
18598 return resultobj;
18599 fail:
18600 return NULL;
18601 }
18602
18603
18604 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18605 PyObject *resultobj = 0;
18606 wxEvent *arg1 = (wxEvent *) 0 ;
18607 long arg2 = (long) 0 ;
18608 void *argp1 = 0 ;
18609 int res1 = 0 ;
18610 long val2 ;
18611 int ecode2 = 0 ;
18612 PyObject * obj0 = 0 ;
18613 PyObject * obj1 = 0 ;
18614 char * kwnames[] = {
18615 (char *) "self",(char *) "ts", NULL
18616 };
18617
18618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18620 if (!SWIG_IsOK(res1)) {
18621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18622 }
18623 arg1 = reinterpret_cast< wxEvent * >(argp1);
18624 if (obj1) {
18625 ecode2 = SWIG_AsVal_long(obj1, &val2);
18626 if (!SWIG_IsOK(ecode2)) {
18627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18628 }
18629 arg2 = static_cast< long >(val2);
18630 }
18631 {
18632 PyThreadState* __tstate = wxPyBeginAllowThreads();
18633 (arg1)->SetTimestamp(arg2);
18634 wxPyEndAllowThreads(__tstate);
18635 if (PyErr_Occurred()) SWIG_fail;
18636 }
18637 resultobj = SWIG_Py_Void();
18638 return resultobj;
18639 fail:
18640 return NULL;
18641 }
18642
18643
18644 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18645 PyObject *resultobj = 0;
18646 wxEvent *arg1 = (wxEvent *) 0 ;
18647 int result;
18648 void *argp1 = 0 ;
18649 int res1 = 0 ;
18650 PyObject *swig_obj[1] ;
18651
18652 if (!args) SWIG_fail;
18653 swig_obj[0] = args;
18654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18655 if (!SWIG_IsOK(res1)) {
18656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18657 }
18658 arg1 = reinterpret_cast< wxEvent * >(argp1);
18659 {
18660 PyThreadState* __tstate = wxPyBeginAllowThreads();
18661 result = (int)((wxEvent const *)arg1)->GetId();
18662 wxPyEndAllowThreads(__tstate);
18663 if (PyErr_Occurred()) SWIG_fail;
18664 }
18665 resultobj = SWIG_From_int(static_cast< int >(result));
18666 return resultobj;
18667 fail:
18668 return NULL;
18669 }
18670
18671
18672 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18673 PyObject *resultobj = 0;
18674 wxEvent *arg1 = (wxEvent *) 0 ;
18675 int arg2 ;
18676 void *argp1 = 0 ;
18677 int res1 = 0 ;
18678 int val2 ;
18679 int ecode2 = 0 ;
18680 PyObject * obj0 = 0 ;
18681 PyObject * obj1 = 0 ;
18682 char * kwnames[] = {
18683 (char *) "self",(char *) "Id", NULL
18684 };
18685
18686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18688 if (!SWIG_IsOK(res1)) {
18689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18690 }
18691 arg1 = reinterpret_cast< wxEvent * >(argp1);
18692 ecode2 = SWIG_AsVal_int(obj1, &val2);
18693 if (!SWIG_IsOK(ecode2)) {
18694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18695 }
18696 arg2 = static_cast< int >(val2);
18697 {
18698 PyThreadState* __tstate = wxPyBeginAllowThreads();
18699 (arg1)->SetId(arg2);
18700 wxPyEndAllowThreads(__tstate);
18701 if (PyErr_Occurred()) SWIG_fail;
18702 }
18703 resultobj = SWIG_Py_Void();
18704 return resultobj;
18705 fail:
18706 return NULL;
18707 }
18708
18709
18710 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18711 PyObject *resultobj = 0;
18712 wxEvent *arg1 = (wxEvent *) 0 ;
18713 bool result;
18714 void *argp1 = 0 ;
18715 int res1 = 0 ;
18716 PyObject *swig_obj[1] ;
18717
18718 if (!args) SWIG_fail;
18719 swig_obj[0] = args;
18720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18721 if (!SWIG_IsOK(res1)) {
18722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18723 }
18724 arg1 = reinterpret_cast< wxEvent * >(argp1);
18725 {
18726 PyThreadState* __tstate = wxPyBeginAllowThreads();
18727 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18728 wxPyEndAllowThreads(__tstate);
18729 if (PyErr_Occurred()) SWIG_fail;
18730 }
18731 {
18732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18733 }
18734 return resultobj;
18735 fail:
18736 return NULL;
18737 }
18738
18739
18740 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18741 PyObject *resultobj = 0;
18742 wxEvent *arg1 = (wxEvent *) 0 ;
18743 bool arg2 = (bool) true ;
18744 void *argp1 = 0 ;
18745 int res1 = 0 ;
18746 bool val2 ;
18747 int ecode2 = 0 ;
18748 PyObject * obj0 = 0 ;
18749 PyObject * obj1 = 0 ;
18750 char * kwnames[] = {
18751 (char *) "self",(char *) "skip", NULL
18752 };
18753
18754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18756 if (!SWIG_IsOK(res1)) {
18757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18758 }
18759 arg1 = reinterpret_cast< wxEvent * >(argp1);
18760 if (obj1) {
18761 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18762 if (!SWIG_IsOK(ecode2)) {
18763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18764 }
18765 arg2 = static_cast< bool >(val2);
18766 }
18767 {
18768 PyThreadState* __tstate = wxPyBeginAllowThreads();
18769 (arg1)->Skip(arg2);
18770 wxPyEndAllowThreads(__tstate);
18771 if (PyErr_Occurred()) SWIG_fail;
18772 }
18773 resultobj = SWIG_Py_Void();
18774 return resultobj;
18775 fail:
18776 return NULL;
18777 }
18778
18779
18780 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18781 PyObject *resultobj = 0;
18782 wxEvent *arg1 = (wxEvent *) 0 ;
18783 bool result;
18784 void *argp1 = 0 ;
18785 int res1 = 0 ;
18786 PyObject *swig_obj[1] ;
18787
18788 if (!args) SWIG_fail;
18789 swig_obj[0] = args;
18790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18791 if (!SWIG_IsOK(res1)) {
18792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18793 }
18794 arg1 = reinterpret_cast< wxEvent * >(argp1);
18795 {
18796 PyThreadState* __tstate = wxPyBeginAllowThreads();
18797 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18798 wxPyEndAllowThreads(__tstate);
18799 if (PyErr_Occurred()) SWIG_fail;
18800 }
18801 {
18802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18803 }
18804 return resultobj;
18805 fail:
18806 return NULL;
18807 }
18808
18809
18810 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18811 PyObject *resultobj = 0;
18812 wxEvent *arg1 = (wxEvent *) 0 ;
18813 bool result;
18814 void *argp1 = 0 ;
18815 int res1 = 0 ;
18816 PyObject *swig_obj[1] ;
18817
18818 if (!args) SWIG_fail;
18819 swig_obj[0] = args;
18820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18821 if (!SWIG_IsOK(res1)) {
18822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18823 }
18824 arg1 = reinterpret_cast< wxEvent * >(argp1);
18825 {
18826 PyThreadState* __tstate = wxPyBeginAllowThreads();
18827 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18828 wxPyEndAllowThreads(__tstate);
18829 if (PyErr_Occurred()) SWIG_fail;
18830 }
18831 {
18832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18833 }
18834 return resultobj;
18835 fail:
18836 return NULL;
18837 }
18838
18839
18840 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18841 PyObject *resultobj = 0;
18842 wxEvent *arg1 = (wxEvent *) 0 ;
18843 int result;
18844 void *argp1 = 0 ;
18845 int res1 = 0 ;
18846 PyObject *swig_obj[1] ;
18847
18848 if (!args) SWIG_fail;
18849 swig_obj[0] = args;
18850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18851 if (!SWIG_IsOK(res1)) {
18852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18853 }
18854 arg1 = reinterpret_cast< wxEvent * >(argp1);
18855 {
18856 PyThreadState* __tstate = wxPyBeginAllowThreads();
18857 result = (int)(arg1)->StopPropagation();
18858 wxPyEndAllowThreads(__tstate);
18859 if (PyErr_Occurred()) SWIG_fail;
18860 }
18861 resultobj = SWIG_From_int(static_cast< int >(result));
18862 return resultobj;
18863 fail:
18864 return NULL;
18865 }
18866
18867
18868 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18869 PyObject *resultobj = 0;
18870 wxEvent *arg1 = (wxEvent *) 0 ;
18871 int arg2 ;
18872 void *argp1 = 0 ;
18873 int res1 = 0 ;
18874 int val2 ;
18875 int ecode2 = 0 ;
18876 PyObject * obj0 = 0 ;
18877 PyObject * obj1 = 0 ;
18878 char * kwnames[] = {
18879 (char *) "self",(char *) "propagationLevel", NULL
18880 };
18881
18882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18884 if (!SWIG_IsOK(res1)) {
18885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18886 }
18887 arg1 = reinterpret_cast< wxEvent * >(argp1);
18888 ecode2 = SWIG_AsVal_int(obj1, &val2);
18889 if (!SWIG_IsOK(ecode2)) {
18890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18891 }
18892 arg2 = static_cast< int >(val2);
18893 {
18894 PyThreadState* __tstate = wxPyBeginAllowThreads();
18895 (arg1)->ResumePropagation(arg2);
18896 wxPyEndAllowThreads(__tstate);
18897 if (PyErr_Occurred()) SWIG_fail;
18898 }
18899 resultobj = SWIG_Py_Void();
18900 return resultobj;
18901 fail:
18902 return NULL;
18903 }
18904
18905
18906 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18907 PyObject *resultobj = 0;
18908 wxEvent *arg1 = (wxEvent *) 0 ;
18909 wxEvent *result = 0 ;
18910 void *argp1 = 0 ;
18911 int res1 = 0 ;
18912 PyObject *swig_obj[1] ;
18913
18914 if (!args) SWIG_fail;
18915 swig_obj[0] = args;
18916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18917 if (!SWIG_IsOK(res1)) {
18918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18919 }
18920 arg1 = reinterpret_cast< wxEvent * >(argp1);
18921 {
18922 PyThreadState* __tstate = wxPyBeginAllowThreads();
18923 result = (wxEvent *)(arg1)->Clone();
18924 wxPyEndAllowThreads(__tstate);
18925 if (PyErr_Occurred()) SWIG_fail;
18926 }
18927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18928 return resultobj;
18929 fail:
18930 return NULL;
18931 }
18932
18933
18934 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18935 PyObject *obj;
18936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18937 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18938 return SWIG_Py_Void();
18939 }
18940
18941 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18942 PyObject *resultobj = 0;
18943 wxEvent *arg1 = 0 ;
18944 wxPropagationDisabler *result = 0 ;
18945 void *argp1 = 0 ;
18946 int res1 = 0 ;
18947 PyObject * obj0 = 0 ;
18948 char * kwnames[] = {
18949 (char *) "event", NULL
18950 };
18951
18952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18953 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18954 if (!SWIG_IsOK(res1)) {
18955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18956 }
18957 if (!argp1) {
18958 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18959 }
18960 arg1 = reinterpret_cast< wxEvent * >(argp1);
18961 {
18962 PyThreadState* __tstate = wxPyBeginAllowThreads();
18963 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18964 wxPyEndAllowThreads(__tstate);
18965 if (PyErr_Occurred()) SWIG_fail;
18966 }
18967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18968 return resultobj;
18969 fail:
18970 return NULL;
18971 }
18972
18973
18974 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18975 PyObject *resultobj = 0;
18976 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18977 void *argp1 = 0 ;
18978 int res1 = 0 ;
18979 PyObject *swig_obj[1] ;
18980
18981 if (!args) SWIG_fail;
18982 swig_obj[0] = args;
18983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18984 if (!SWIG_IsOK(res1)) {
18985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18986 }
18987 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18988 {
18989 PyThreadState* __tstate = wxPyBeginAllowThreads();
18990 delete arg1;
18991
18992 wxPyEndAllowThreads(__tstate);
18993 if (PyErr_Occurred()) SWIG_fail;
18994 }
18995 resultobj = SWIG_Py_Void();
18996 return resultobj;
18997 fail:
18998 return NULL;
18999 }
19000
19001
19002 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19003 PyObject *obj;
19004 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19005 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
19006 return SWIG_Py_Void();
19007 }
19008
19009 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19010 return SWIG_Python_InitShadowInstance(args);
19011 }
19012
19013 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19014 PyObject *resultobj = 0;
19015 wxEvent *arg1 = 0 ;
19016 wxPropagateOnce *result = 0 ;
19017 void *argp1 = 0 ;
19018 int res1 = 0 ;
19019 PyObject * obj0 = 0 ;
19020 char * kwnames[] = {
19021 (char *) "event", NULL
19022 };
19023
19024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
19025 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
19026 if (!SWIG_IsOK(res1)) {
19027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19028 }
19029 if (!argp1) {
19030 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
19031 }
19032 arg1 = reinterpret_cast< wxEvent * >(argp1);
19033 {
19034 PyThreadState* __tstate = wxPyBeginAllowThreads();
19035 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
19036 wxPyEndAllowThreads(__tstate);
19037 if (PyErr_Occurred()) SWIG_fail;
19038 }
19039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
19040 return resultobj;
19041 fail:
19042 return NULL;
19043 }
19044
19045
19046 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19047 PyObject *resultobj = 0;
19048 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
19049 void *argp1 = 0 ;
19050 int res1 = 0 ;
19051 PyObject *swig_obj[1] ;
19052
19053 if (!args) SWIG_fail;
19054 swig_obj[0] = args;
19055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
19056 if (!SWIG_IsOK(res1)) {
19057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
19058 }
19059 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
19060 {
19061 PyThreadState* __tstate = wxPyBeginAllowThreads();
19062 delete arg1;
19063
19064 wxPyEndAllowThreads(__tstate);
19065 if (PyErr_Occurred()) SWIG_fail;
19066 }
19067 resultobj = SWIG_Py_Void();
19068 return resultobj;
19069 fail:
19070 return NULL;
19071 }
19072
19073
19074 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19075 PyObject *obj;
19076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19077 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
19078 return SWIG_Py_Void();
19079 }
19080
19081 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19082 return SWIG_Python_InitShadowInstance(args);
19083 }
19084
19085 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19086 PyObject *resultobj = 0;
19087 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19088 int arg2 = (int) 0 ;
19089 wxCommandEvent *result = 0 ;
19090 int val1 ;
19091 int ecode1 = 0 ;
19092 int val2 ;
19093 int ecode2 = 0 ;
19094 PyObject * obj0 = 0 ;
19095 PyObject * obj1 = 0 ;
19096 char * kwnames[] = {
19097 (char *) "commandType",(char *) "winid", NULL
19098 };
19099
19100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19101 if (obj0) {
19102 ecode1 = SWIG_AsVal_int(obj0, &val1);
19103 if (!SWIG_IsOK(ecode1)) {
19104 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19105 }
19106 arg1 = static_cast< wxEventType >(val1);
19107 }
19108 if (obj1) {
19109 ecode2 = SWIG_AsVal_int(obj1, &val2);
19110 if (!SWIG_IsOK(ecode2)) {
19111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
19112 }
19113 arg2 = static_cast< int >(val2);
19114 }
19115 {
19116 PyThreadState* __tstate = wxPyBeginAllowThreads();
19117 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
19118 wxPyEndAllowThreads(__tstate);
19119 if (PyErr_Occurred()) SWIG_fail;
19120 }
19121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
19122 return resultobj;
19123 fail:
19124 return NULL;
19125 }
19126
19127
19128 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19129 PyObject *resultobj = 0;
19130 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19131 int result;
19132 void *argp1 = 0 ;
19133 int res1 = 0 ;
19134 PyObject *swig_obj[1] ;
19135
19136 if (!args) SWIG_fail;
19137 swig_obj[0] = args;
19138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19139 if (!SWIG_IsOK(res1)) {
19140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19141 }
19142 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19143 {
19144 PyThreadState* __tstate = wxPyBeginAllowThreads();
19145 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
19146 wxPyEndAllowThreads(__tstate);
19147 if (PyErr_Occurred()) SWIG_fail;
19148 }
19149 resultobj = SWIG_From_int(static_cast< int >(result));
19150 return resultobj;
19151 fail:
19152 return NULL;
19153 }
19154
19155
19156 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19157 PyObject *resultobj = 0;
19158 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19159 wxString *arg2 = 0 ;
19160 void *argp1 = 0 ;
19161 int res1 = 0 ;
19162 bool temp2 = false ;
19163 PyObject * obj0 = 0 ;
19164 PyObject * obj1 = 0 ;
19165 char * kwnames[] = {
19166 (char *) "self",(char *) "s", NULL
19167 };
19168
19169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
19170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19171 if (!SWIG_IsOK(res1)) {
19172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19173 }
19174 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19175 {
19176 arg2 = wxString_in_helper(obj1);
19177 if (arg2 == NULL) SWIG_fail;
19178 temp2 = true;
19179 }
19180 {
19181 PyThreadState* __tstate = wxPyBeginAllowThreads();
19182 (arg1)->SetString((wxString const &)*arg2);
19183 wxPyEndAllowThreads(__tstate);
19184 if (PyErr_Occurred()) SWIG_fail;
19185 }
19186 resultobj = SWIG_Py_Void();
19187 {
19188 if (temp2)
19189 delete arg2;
19190 }
19191 return resultobj;
19192 fail:
19193 {
19194 if (temp2)
19195 delete arg2;
19196 }
19197 return NULL;
19198 }
19199
19200
19201 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19202 PyObject *resultobj = 0;
19203 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19204 wxString result;
19205 void *argp1 = 0 ;
19206 int res1 = 0 ;
19207 PyObject *swig_obj[1] ;
19208
19209 if (!args) SWIG_fail;
19210 swig_obj[0] = args;
19211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19212 if (!SWIG_IsOK(res1)) {
19213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19214 }
19215 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19216 {
19217 PyThreadState* __tstate = wxPyBeginAllowThreads();
19218 result = ((wxCommandEvent const *)arg1)->GetString();
19219 wxPyEndAllowThreads(__tstate);
19220 if (PyErr_Occurred()) SWIG_fail;
19221 }
19222 {
19223 #if wxUSE_UNICODE
19224 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19225 #else
19226 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19227 #endif
19228 }
19229 return resultobj;
19230 fail:
19231 return NULL;
19232 }
19233
19234
19235 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19236 PyObject *resultobj = 0;
19237 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19238 bool result;
19239 void *argp1 = 0 ;
19240 int res1 = 0 ;
19241 PyObject *swig_obj[1] ;
19242
19243 if (!args) SWIG_fail;
19244 swig_obj[0] = args;
19245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19246 if (!SWIG_IsOK(res1)) {
19247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19248 }
19249 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19250 {
19251 PyThreadState* __tstate = wxPyBeginAllowThreads();
19252 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19253 wxPyEndAllowThreads(__tstate);
19254 if (PyErr_Occurred()) SWIG_fail;
19255 }
19256 {
19257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19258 }
19259 return resultobj;
19260 fail:
19261 return NULL;
19262 }
19263
19264
19265 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19266 PyObject *resultobj = 0;
19267 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19268 bool result;
19269 void *argp1 = 0 ;
19270 int res1 = 0 ;
19271 PyObject *swig_obj[1] ;
19272
19273 if (!args) SWIG_fail;
19274 swig_obj[0] = args;
19275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19276 if (!SWIG_IsOK(res1)) {
19277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19278 }
19279 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19280 {
19281 PyThreadState* __tstate = wxPyBeginAllowThreads();
19282 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19283 wxPyEndAllowThreads(__tstate);
19284 if (PyErr_Occurred()) SWIG_fail;
19285 }
19286 {
19287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19288 }
19289 return resultobj;
19290 fail:
19291 return NULL;
19292 }
19293
19294
19295 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19296 PyObject *resultobj = 0;
19297 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19298 long arg2 ;
19299 void *argp1 = 0 ;
19300 int res1 = 0 ;
19301 long val2 ;
19302 int ecode2 = 0 ;
19303 PyObject * obj0 = 0 ;
19304 PyObject * obj1 = 0 ;
19305 char * kwnames[] = {
19306 (char *) "self",(char *) "extraLong", NULL
19307 };
19308
19309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19311 if (!SWIG_IsOK(res1)) {
19312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19313 }
19314 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19315 ecode2 = SWIG_AsVal_long(obj1, &val2);
19316 if (!SWIG_IsOK(ecode2)) {
19317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19318 }
19319 arg2 = static_cast< long >(val2);
19320 {
19321 PyThreadState* __tstate = wxPyBeginAllowThreads();
19322 (arg1)->SetExtraLong(arg2);
19323 wxPyEndAllowThreads(__tstate);
19324 if (PyErr_Occurred()) SWIG_fail;
19325 }
19326 resultobj = SWIG_Py_Void();
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19334 PyObject *resultobj = 0;
19335 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19336 long result;
19337 void *argp1 = 0 ;
19338 int res1 = 0 ;
19339 PyObject *swig_obj[1] ;
19340
19341 if (!args) SWIG_fail;
19342 swig_obj[0] = args;
19343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19344 if (!SWIG_IsOK(res1)) {
19345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19346 }
19347 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19348 {
19349 PyThreadState* __tstate = wxPyBeginAllowThreads();
19350 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19351 wxPyEndAllowThreads(__tstate);
19352 if (PyErr_Occurred()) SWIG_fail;
19353 }
19354 resultobj = SWIG_From_long(static_cast< long >(result));
19355 return resultobj;
19356 fail:
19357 return NULL;
19358 }
19359
19360
19361 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19362 PyObject *resultobj = 0;
19363 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19364 int arg2 ;
19365 void *argp1 = 0 ;
19366 int res1 = 0 ;
19367 int val2 ;
19368 int ecode2 = 0 ;
19369 PyObject * obj0 = 0 ;
19370 PyObject * obj1 = 0 ;
19371 char * kwnames[] = {
19372 (char *) "self",(char *) "i", NULL
19373 };
19374
19375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19377 if (!SWIG_IsOK(res1)) {
19378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19379 }
19380 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19381 ecode2 = SWIG_AsVal_int(obj1, &val2);
19382 if (!SWIG_IsOK(ecode2)) {
19383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19384 }
19385 arg2 = static_cast< int >(val2);
19386 {
19387 PyThreadState* __tstate = wxPyBeginAllowThreads();
19388 (arg1)->SetInt(arg2);
19389 wxPyEndAllowThreads(__tstate);
19390 if (PyErr_Occurred()) SWIG_fail;
19391 }
19392 resultobj = SWIG_Py_Void();
19393 return resultobj;
19394 fail:
19395 return NULL;
19396 }
19397
19398
19399 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19400 PyObject *resultobj = 0;
19401 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19402 int result;
19403 void *argp1 = 0 ;
19404 int res1 = 0 ;
19405 PyObject *swig_obj[1] ;
19406
19407 if (!args) SWIG_fail;
19408 swig_obj[0] = args;
19409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19410 if (!SWIG_IsOK(res1)) {
19411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19412 }
19413 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19414 {
19415 PyThreadState* __tstate = wxPyBeginAllowThreads();
19416 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19417 wxPyEndAllowThreads(__tstate);
19418 if (PyErr_Occurred()) SWIG_fail;
19419 }
19420 resultobj = SWIG_From_int(static_cast< int >(result));
19421 return resultobj;
19422 fail:
19423 return NULL;
19424 }
19425
19426
19427 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19428 PyObject *resultobj = 0;
19429 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19430 PyObject *result = 0 ;
19431 void *argp1 = 0 ;
19432 int res1 = 0 ;
19433 PyObject *swig_obj[1] ;
19434
19435 if (!args) SWIG_fail;
19436 swig_obj[0] = args;
19437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19438 if (!SWIG_IsOK(res1)) {
19439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19440 }
19441 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19442 {
19443 PyThreadState* __tstate = wxPyBeginAllowThreads();
19444 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19445 wxPyEndAllowThreads(__tstate);
19446 if (PyErr_Occurred()) SWIG_fail;
19447 }
19448 resultobj = result;
19449 return resultobj;
19450 fail:
19451 return NULL;
19452 }
19453
19454
19455 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19456 PyObject *resultobj = 0;
19457 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19458 PyObject *arg2 = (PyObject *) 0 ;
19459 void *argp1 = 0 ;
19460 int res1 = 0 ;
19461 PyObject * obj0 = 0 ;
19462 PyObject * obj1 = 0 ;
19463 char * kwnames[] = {
19464 (char *) "self",(char *) "clientData", NULL
19465 };
19466
19467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19469 if (!SWIG_IsOK(res1)) {
19470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19471 }
19472 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19473 arg2 = obj1;
19474 {
19475 PyThreadState* __tstate = wxPyBeginAllowThreads();
19476 wxCommandEvent_SetClientData(arg1,arg2);
19477 wxPyEndAllowThreads(__tstate);
19478 if (PyErr_Occurred()) SWIG_fail;
19479 }
19480 resultobj = SWIG_Py_Void();
19481 return resultobj;
19482 fail:
19483 return NULL;
19484 }
19485
19486
19487 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19488 PyObject *resultobj = 0;
19489 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19490 wxEvent *result = 0 ;
19491 void *argp1 = 0 ;
19492 int res1 = 0 ;
19493 PyObject *swig_obj[1] ;
19494
19495 if (!args) SWIG_fail;
19496 swig_obj[0] = args;
19497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19498 if (!SWIG_IsOK(res1)) {
19499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19500 }
19501 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19502 {
19503 PyThreadState* __tstate = wxPyBeginAllowThreads();
19504 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19505 wxPyEndAllowThreads(__tstate);
19506 if (PyErr_Occurred()) SWIG_fail;
19507 }
19508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19509 return resultobj;
19510 fail:
19511 return NULL;
19512 }
19513
19514
19515 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19516 PyObject *obj;
19517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19518 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19519 return SWIG_Py_Void();
19520 }
19521
19522 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19523 return SWIG_Python_InitShadowInstance(args);
19524 }
19525
19526 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19527 PyObject *resultobj = 0;
19528 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19529 int arg2 = (int) 0 ;
19530 wxNotifyEvent *result = 0 ;
19531 int val1 ;
19532 int ecode1 = 0 ;
19533 int val2 ;
19534 int ecode2 = 0 ;
19535 PyObject * obj0 = 0 ;
19536 PyObject * obj1 = 0 ;
19537 char * kwnames[] = {
19538 (char *) "commandType",(char *) "winid", NULL
19539 };
19540
19541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19542 if (obj0) {
19543 ecode1 = SWIG_AsVal_int(obj0, &val1);
19544 if (!SWIG_IsOK(ecode1)) {
19545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19546 }
19547 arg1 = static_cast< wxEventType >(val1);
19548 }
19549 if (obj1) {
19550 ecode2 = SWIG_AsVal_int(obj1, &val2);
19551 if (!SWIG_IsOK(ecode2)) {
19552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19553 }
19554 arg2 = static_cast< int >(val2);
19555 }
19556 {
19557 PyThreadState* __tstate = wxPyBeginAllowThreads();
19558 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19559 wxPyEndAllowThreads(__tstate);
19560 if (PyErr_Occurred()) SWIG_fail;
19561 }
19562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19563 return resultobj;
19564 fail:
19565 return NULL;
19566 }
19567
19568
19569 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19570 PyObject *resultobj = 0;
19571 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19572 void *argp1 = 0 ;
19573 int res1 = 0 ;
19574 PyObject *swig_obj[1] ;
19575
19576 if (!args) SWIG_fail;
19577 swig_obj[0] = args;
19578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19579 if (!SWIG_IsOK(res1)) {
19580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19581 }
19582 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19583 {
19584 PyThreadState* __tstate = wxPyBeginAllowThreads();
19585 (arg1)->Veto();
19586 wxPyEndAllowThreads(__tstate);
19587 if (PyErr_Occurred()) SWIG_fail;
19588 }
19589 resultobj = SWIG_Py_Void();
19590 return resultobj;
19591 fail:
19592 return NULL;
19593 }
19594
19595
19596 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19597 PyObject *resultobj = 0;
19598 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19599 void *argp1 = 0 ;
19600 int res1 = 0 ;
19601 PyObject *swig_obj[1] ;
19602
19603 if (!args) SWIG_fail;
19604 swig_obj[0] = args;
19605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19606 if (!SWIG_IsOK(res1)) {
19607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19608 }
19609 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19610 {
19611 PyThreadState* __tstate = wxPyBeginAllowThreads();
19612 (arg1)->Allow();
19613 wxPyEndAllowThreads(__tstate);
19614 if (PyErr_Occurred()) SWIG_fail;
19615 }
19616 resultobj = SWIG_Py_Void();
19617 return resultobj;
19618 fail:
19619 return NULL;
19620 }
19621
19622
19623 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19624 PyObject *resultobj = 0;
19625 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19626 bool result;
19627 void *argp1 = 0 ;
19628 int res1 = 0 ;
19629 PyObject *swig_obj[1] ;
19630
19631 if (!args) SWIG_fail;
19632 swig_obj[0] = args;
19633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19634 if (!SWIG_IsOK(res1)) {
19635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19636 }
19637 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19638 {
19639 PyThreadState* __tstate = wxPyBeginAllowThreads();
19640 result = (bool)(arg1)->IsAllowed();
19641 wxPyEndAllowThreads(__tstate);
19642 if (PyErr_Occurred()) SWIG_fail;
19643 }
19644 {
19645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19646 }
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19654 PyObject *obj;
19655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19656 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19657 return SWIG_Py_Void();
19658 }
19659
19660 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19661 return SWIG_Python_InitShadowInstance(args);
19662 }
19663
19664 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19665 PyObject *resultobj = 0;
19666 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19667 int arg2 = (int) 0 ;
19668 int arg3 = (int) 0 ;
19669 int arg4 = (int) 0 ;
19670 wxScrollEvent *result = 0 ;
19671 int val1 ;
19672 int ecode1 = 0 ;
19673 int val2 ;
19674 int ecode2 = 0 ;
19675 int val3 ;
19676 int ecode3 = 0 ;
19677 int val4 ;
19678 int ecode4 = 0 ;
19679 PyObject * obj0 = 0 ;
19680 PyObject * obj1 = 0 ;
19681 PyObject * obj2 = 0 ;
19682 PyObject * obj3 = 0 ;
19683 char * kwnames[] = {
19684 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19685 };
19686
19687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19688 if (obj0) {
19689 ecode1 = SWIG_AsVal_int(obj0, &val1);
19690 if (!SWIG_IsOK(ecode1)) {
19691 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19692 }
19693 arg1 = static_cast< wxEventType >(val1);
19694 }
19695 if (obj1) {
19696 ecode2 = SWIG_AsVal_int(obj1, &val2);
19697 if (!SWIG_IsOK(ecode2)) {
19698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19699 }
19700 arg2 = static_cast< int >(val2);
19701 }
19702 if (obj2) {
19703 ecode3 = SWIG_AsVal_int(obj2, &val3);
19704 if (!SWIG_IsOK(ecode3)) {
19705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19706 }
19707 arg3 = static_cast< int >(val3);
19708 }
19709 if (obj3) {
19710 ecode4 = SWIG_AsVal_int(obj3, &val4);
19711 if (!SWIG_IsOK(ecode4)) {
19712 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19713 }
19714 arg4 = static_cast< int >(val4);
19715 }
19716 {
19717 PyThreadState* __tstate = wxPyBeginAllowThreads();
19718 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19719 wxPyEndAllowThreads(__tstate);
19720 if (PyErr_Occurred()) SWIG_fail;
19721 }
19722 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19723 return resultobj;
19724 fail:
19725 return NULL;
19726 }
19727
19728
19729 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19730 PyObject *resultobj = 0;
19731 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19732 int result;
19733 void *argp1 = 0 ;
19734 int res1 = 0 ;
19735 PyObject *swig_obj[1] ;
19736
19737 if (!args) SWIG_fail;
19738 swig_obj[0] = args;
19739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19740 if (!SWIG_IsOK(res1)) {
19741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19742 }
19743 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19744 {
19745 PyThreadState* __tstate = wxPyBeginAllowThreads();
19746 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19747 wxPyEndAllowThreads(__tstate);
19748 if (PyErr_Occurred()) SWIG_fail;
19749 }
19750 resultobj = SWIG_From_int(static_cast< int >(result));
19751 return resultobj;
19752 fail:
19753 return NULL;
19754 }
19755
19756
19757 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19758 PyObject *resultobj = 0;
19759 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19760 int result;
19761 void *argp1 = 0 ;
19762 int res1 = 0 ;
19763 PyObject *swig_obj[1] ;
19764
19765 if (!args) SWIG_fail;
19766 swig_obj[0] = args;
19767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19768 if (!SWIG_IsOK(res1)) {
19769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19770 }
19771 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19772 {
19773 PyThreadState* __tstate = wxPyBeginAllowThreads();
19774 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19775 wxPyEndAllowThreads(__tstate);
19776 if (PyErr_Occurred()) SWIG_fail;
19777 }
19778 resultobj = SWIG_From_int(static_cast< int >(result));
19779 return resultobj;
19780 fail:
19781 return NULL;
19782 }
19783
19784
19785 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19786 PyObject *resultobj = 0;
19787 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19788 int arg2 ;
19789 void *argp1 = 0 ;
19790 int res1 = 0 ;
19791 int val2 ;
19792 int ecode2 = 0 ;
19793 PyObject * obj0 = 0 ;
19794 PyObject * obj1 = 0 ;
19795 char * kwnames[] = {
19796 (char *) "self",(char *) "orient", NULL
19797 };
19798
19799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19801 if (!SWIG_IsOK(res1)) {
19802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19803 }
19804 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19805 ecode2 = SWIG_AsVal_int(obj1, &val2);
19806 if (!SWIG_IsOK(ecode2)) {
19807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19808 }
19809 arg2 = static_cast< int >(val2);
19810 {
19811 PyThreadState* __tstate = wxPyBeginAllowThreads();
19812 (arg1)->SetOrientation(arg2);
19813 wxPyEndAllowThreads(__tstate);
19814 if (PyErr_Occurred()) SWIG_fail;
19815 }
19816 resultobj = SWIG_Py_Void();
19817 return resultobj;
19818 fail:
19819 return NULL;
19820 }
19821
19822
19823 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj = 0;
19825 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19826 int arg2 ;
19827 void *argp1 = 0 ;
19828 int res1 = 0 ;
19829 int val2 ;
19830 int ecode2 = 0 ;
19831 PyObject * obj0 = 0 ;
19832 PyObject * obj1 = 0 ;
19833 char * kwnames[] = {
19834 (char *) "self",(char *) "pos", NULL
19835 };
19836
19837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19839 if (!SWIG_IsOK(res1)) {
19840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19841 }
19842 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19843 ecode2 = SWIG_AsVal_int(obj1, &val2);
19844 if (!SWIG_IsOK(ecode2)) {
19845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19846 }
19847 arg2 = static_cast< int >(val2);
19848 {
19849 PyThreadState* __tstate = wxPyBeginAllowThreads();
19850 (arg1)->SetPosition(arg2);
19851 wxPyEndAllowThreads(__tstate);
19852 if (PyErr_Occurred()) SWIG_fail;
19853 }
19854 resultobj = SWIG_Py_Void();
19855 return resultobj;
19856 fail:
19857 return NULL;
19858 }
19859
19860
19861 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19862 PyObject *obj;
19863 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19864 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19865 return SWIG_Py_Void();
19866 }
19867
19868 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19869 return SWIG_Python_InitShadowInstance(args);
19870 }
19871
19872 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19873 PyObject *resultobj = 0;
19874 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19875 int arg2 = (int) 0 ;
19876 int arg3 = (int) 0 ;
19877 wxScrollWinEvent *result = 0 ;
19878 int val1 ;
19879 int ecode1 = 0 ;
19880 int val2 ;
19881 int ecode2 = 0 ;
19882 int val3 ;
19883 int ecode3 = 0 ;
19884 PyObject * obj0 = 0 ;
19885 PyObject * obj1 = 0 ;
19886 PyObject * obj2 = 0 ;
19887 char * kwnames[] = {
19888 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19889 };
19890
19891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19892 if (obj0) {
19893 ecode1 = SWIG_AsVal_int(obj0, &val1);
19894 if (!SWIG_IsOK(ecode1)) {
19895 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19896 }
19897 arg1 = static_cast< wxEventType >(val1);
19898 }
19899 if (obj1) {
19900 ecode2 = SWIG_AsVal_int(obj1, &val2);
19901 if (!SWIG_IsOK(ecode2)) {
19902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19903 }
19904 arg2 = static_cast< int >(val2);
19905 }
19906 if (obj2) {
19907 ecode3 = SWIG_AsVal_int(obj2, &val3);
19908 if (!SWIG_IsOK(ecode3)) {
19909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19910 }
19911 arg3 = static_cast< int >(val3);
19912 }
19913 {
19914 PyThreadState* __tstate = wxPyBeginAllowThreads();
19915 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19916 wxPyEndAllowThreads(__tstate);
19917 if (PyErr_Occurred()) SWIG_fail;
19918 }
19919 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19920 return resultobj;
19921 fail:
19922 return NULL;
19923 }
19924
19925
19926 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19927 PyObject *resultobj = 0;
19928 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19929 int result;
19930 void *argp1 = 0 ;
19931 int res1 = 0 ;
19932 PyObject *swig_obj[1] ;
19933
19934 if (!args) SWIG_fail;
19935 swig_obj[0] = args;
19936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19937 if (!SWIG_IsOK(res1)) {
19938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19939 }
19940 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19941 {
19942 PyThreadState* __tstate = wxPyBeginAllowThreads();
19943 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19944 wxPyEndAllowThreads(__tstate);
19945 if (PyErr_Occurred()) SWIG_fail;
19946 }
19947 resultobj = SWIG_From_int(static_cast< int >(result));
19948 return resultobj;
19949 fail:
19950 return NULL;
19951 }
19952
19953
19954 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19955 PyObject *resultobj = 0;
19956 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19957 int result;
19958 void *argp1 = 0 ;
19959 int res1 = 0 ;
19960 PyObject *swig_obj[1] ;
19961
19962 if (!args) SWIG_fail;
19963 swig_obj[0] = args;
19964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19965 if (!SWIG_IsOK(res1)) {
19966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19967 }
19968 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19969 {
19970 PyThreadState* __tstate = wxPyBeginAllowThreads();
19971 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19972 wxPyEndAllowThreads(__tstate);
19973 if (PyErr_Occurred()) SWIG_fail;
19974 }
19975 resultobj = SWIG_From_int(static_cast< int >(result));
19976 return resultobj;
19977 fail:
19978 return NULL;
19979 }
19980
19981
19982 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19983 PyObject *resultobj = 0;
19984 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19985 int arg2 ;
19986 void *argp1 = 0 ;
19987 int res1 = 0 ;
19988 int val2 ;
19989 int ecode2 = 0 ;
19990 PyObject * obj0 = 0 ;
19991 PyObject * obj1 = 0 ;
19992 char * kwnames[] = {
19993 (char *) "self",(char *) "orient", NULL
19994 };
19995
19996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19998 if (!SWIG_IsOK(res1)) {
19999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20000 }
20001 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20002 ecode2 = SWIG_AsVal_int(obj1, &val2);
20003 if (!SWIG_IsOK(ecode2)) {
20004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
20005 }
20006 arg2 = static_cast< int >(val2);
20007 {
20008 PyThreadState* __tstate = wxPyBeginAllowThreads();
20009 (arg1)->SetOrientation(arg2);
20010 wxPyEndAllowThreads(__tstate);
20011 if (PyErr_Occurred()) SWIG_fail;
20012 }
20013 resultobj = SWIG_Py_Void();
20014 return resultobj;
20015 fail:
20016 return NULL;
20017 }
20018
20019
20020 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20021 PyObject *resultobj = 0;
20022 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
20023 int arg2 ;
20024 void *argp1 = 0 ;
20025 int res1 = 0 ;
20026 int val2 ;
20027 int ecode2 = 0 ;
20028 PyObject * obj0 = 0 ;
20029 PyObject * obj1 = 0 ;
20030 char * kwnames[] = {
20031 (char *) "self",(char *) "pos", NULL
20032 };
20033
20034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
20036 if (!SWIG_IsOK(res1)) {
20037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
20038 }
20039 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
20040 ecode2 = SWIG_AsVal_int(obj1, &val2);
20041 if (!SWIG_IsOK(ecode2)) {
20042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
20043 }
20044 arg2 = static_cast< int >(val2);
20045 {
20046 PyThreadState* __tstate = wxPyBeginAllowThreads();
20047 (arg1)->SetPosition(arg2);
20048 wxPyEndAllowThreads(__tstate);
20049 if (PyErr_Occurred()) SWIG_fail;
20050 }
20051 resultobj = SWIG_Py_Void();
20052 return resultobj;
20053 fail:
20054 return NULL;
20055 }
20056
20057
20058 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20059 PyObject *obj;
20060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20061 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
20062 return SWIG_Py_Void();
20063 }
20064
20065 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20066 return SWIG_Python_InitShadowInstance(args);
20067 }
20068
20069 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20070 PyObject *resultobj = 0;
20071 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20072 wxMouseEvent *result = 0 ;
20073 int val1 ;
20074 int ecode1 = 0 ;
20075 PyObject * obj0 = 0 ;
20076 char * kwnames[] = {
20077 (char *) "mouseType", NULL
20078 };
20079
20080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
20081 if (obj0) {
20082 ecode1 = SWIG_AsVal_int(obj0, &val1);
20083 if (!SWIG_IsOK(ecode1)) {
20084 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
20085 }
20086 arg1 = static_cast< wxEventType >(val1);
20087 }
20088 {
20089 PyThreadState* __tstate = wxPyBeginAllowThreads();
20090 result = (wxMouseEvent *)new wxMouseEvent(arg1);
20091 wxPyEndAllowThreads(__tstate);
20092 if (PyErr_Occurred()) SWIG_fail;
20093 }
20094 {
20095 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
20096 }
20097 return resultobj;
20098 fail:
20099 return NULL;
20100 }
20101
20102
20103 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20104 PyObject *resultobj = 0;
20105 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20106 bool result;
20107 void *argp1 = 0 ;
20108 int res1 = 0 ;
20109 PyObject *swig_obj[1] ;
20110
20111 if (!args) SWIG_fail;
20112 swig_obj[0] = args;
20113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20114 if (!SWIG_IsOK(res1)) {
20115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20116 }
20117 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20118 {
20119 PyThreadState* __tstate = wxPyBeginAllowThreads();
20120 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
20121 wxPyEndAllowThreads(__tstate);
20122 if (PyErr_Occurred()) SWIG_fail;
20123 }
20124 {
20125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20126 }
20127 return resultobj;
20128 fail:
20129 return NULL;
20130 }
20131
20132
20133 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20134 PyObject *resultobj = 0;
20135 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20136 int arg2 = (int) wxMOUSE_BTN_ANY ;
20137 bool result;
20138 void *argp1 = 0 ;
20139 int res1 = 0 ;
20140 int val2 ;
20141 int ecode2 = 0 ;
20142 PyObject * obj0 = 0 ;
20143 PyObject * obj1 = 0 ;
20144 char * kwnames[] = {
20145 (char *) "self",(char *) "but", NULL
20146 };
20147
20148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
20149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20150 if (!SWIG_IsOK(res1)) {
20151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20152 }
20153 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20154 if (obj1) {
20155 ecode2 = SWIG_AsVal_int(obj1, &val2);
20156 if (!SWIG_IsOK(ecode2)) {
20157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
20158 }
20159 arg2 = static_cast< int >(val2);
20160 }
20161 {
20162 PyThreadState* __tstate = wxPyBeginAllowThreads();
20163 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 {
20168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20169 }
20170 return resultobj;
20171 fail:
20172 return NULL;
20173 }
20174
20175
20176 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20177 PyObject *resultobj = 0;
20178 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20179 int arg2 = (int) wxMOUSE_BTN_ANY ;
20180 bool result;
20181 void *argp1 = 0 ;
20182 int res1 = 0 ;
20183 int val2 ;
20184 int ecode2 = 0 ;
20185 PyObject * obj0 = 0 ;
20186 PyObject * obj1 = 0 ;
20187 char * kwnames[] = {
20188 (char *) "self",(char *) "but", NULL
20189 };
20190
20191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
20192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20193 if (!SWIG_IsOK(res1)) {
20194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20195 }
20196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20197 if (obj1) {
20198 ecode2 = SWIG_AsVal_int(obj1, &val2);
20199 if (!SWIG_IsOK(ecode2)) {
20200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20201 }
20202 arg2 = static_cast< int >(val2);
20203 }
20204 {
20205 PyThreadState* __tstate = wxPyBeginAllowThreads();
20206 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20207 wxPyEndAllowThreads(__tstate);
20208 if (PyErr_Occurred()) SWIG_fail;
20209 }
20210 {
20211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20212 }
20213 return resultobj;
20214 fail:
20215 return NULL;
20216 }
20217
20218
20219 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20220 PyObject *resultobj = 0;
20221 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20222 int arg2 = (int) wxMOUSE_BTN_ANY ;
20223 bool result;
20224 void *argp1 = 0 ;
20225 int res1 = 0 ;
20226 int val2 ;
20227 int ecode2 = 0 ;
20228 PyObject * obj0 = 0 ;
20229 PyObject * obj1 = 0 ;
20230 char * kwnames[] = {
20231 (char *) "self",(char *) "but", NULL
20232 };
20233
20234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20236 if (!SWIG_IsOK(res1)) {
20237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20238 }
20239 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20240 if (obj1) {
20241 ecode2 = SWIG_AsVal_int(obj1, &val2);
20242 if (!SWIG_IsOK(ecode2)) {
20243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20244 }
20245 arg2 = static_cast< int >(val2);
20246 }
20247 {
20248 PyThreadState* __tstate = wxPyBeginAllowThreads();
20249 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20250 wxPyEndAllowThreads(__tstate);
20251 if (PyErr_Occurred()) SWIG_fail;
20252 }
20253 {
20254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20255 }
20256 return resultobj;
20257 fail:
20258 return NULL;
20259 }
20260
20261
20262 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20263 PyObject *resultobj = 0;
20264 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20265 int arg2 ;
20266 bool result;
20267 void *argp1 = 0 ;
20268 int res1 = 0 ;
20269 int val2 ;
20270 int ecode2 = 0 ;
20271 PyObject * obj0 = 0 ;
20272 PyObject * obj1 = 0 ;
20273 char * kwnames[] = {
20274 (char *) "self",(char *) "button", NULL
20275 };
20276
20277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20279 if (!SWIG_IsOK(res1)) {
20280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20281 }
20282 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20283 ecode2 = SWIG_AsVal_int(obj1, &val2);
20284 if (!SWIG_IsOK(ecode2)) {
20285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20286 }
20287 arg2 = static_cast< int >(val2);
20288 {
20289 PyThreadState* __tstate = wxPyBeginAllowThreads();
20290 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20291 wxPyEndAllowThreads(__tstate);
20292 if (PyErr_Occurred()) SWIG_fail;
20293 }
20294 {
20295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20296 }
20297 return resultobj;
20298 fail:
20299 return NULL;
20300 }
20301
20302
20303 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20304 PyObject *resultobj = 0;
20305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20306 int arg2 ;
20307 bool result;
20308 void *argp1 = 0 ;
20309 int res1 = 0 ;
20310 int val2 ;
20311 int ecode2 = 0 ;
20312 PyObject * obj0 = 0 ;
20313 PyObject * obj1 = 0 ;
20314 char * kwnames[] = {
20315 (char *) "self",(char *) "but", NULL
20316 };
20317
20318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20320 if (!SWIG_IsOK(res1)) {
20321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20322 }
20323 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20324 ecode2 = SWIG_AsVal_int(obj1, &val2);
20325 if (!SWIG_IsOK(ecode2)) {
20326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20327 }
20328 arg2 = static_cast< int >(val2);
20329 {
20330 PyThreadState* __tstate = wxPyBeginAllowThreads();
20331 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20332 wxPyEndAllowThreads(__tstate);
20333 if (PyErr_Occurred()) SWIG_fail;
20334 }
20335 {
20336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20337 }
20338 return resultobj;
20339 fail:
20340 return NULL;
20341 }
20342
20343
20344 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20345 PyObject *resultobj = 0;
20346 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20347 int result;
20348 void *argp1 = 0 ;
20349 int res1 = 0 ;
20350 PyObject *swig_obj[1] ;
20351
20352 if (!args) SWIG_fail;
20353 swig_obj[0] = args;
20354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20355 if (!SWIG_IsOK(res1)) {
20356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20357 }
20358 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20359 {
20360 PyThreadState* __tstate = wxPyBeginAllowThreads();
20361 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20362 wxPyEndAllowThreads(__tstate);
20363 if (PyErr_Occurred()) SWIG_fail;
20364 }
20365 resultobj = SWIG_From_int(static_cast< int >(result));
20366 return resultobj;
20367 fail:
20368 return NULL;
20369 }
20370
20371
20372 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20373 PyObject *resultobj = 0;
20374 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20375 bool result;
20376 void *argp1 = 0 ;
20377 int res1 = 0 ;
20378 PyObject *swig_obj[1] ;
20379
20380 if (!args) SWIG_fail;
20381 swig_obj[0] = args;
20382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20383 if (!SWIG_IsOK(res1)) {
20384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20385 }
20386 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20387 {
20388 PyThreadState* __tstate = wxPyBeginAllowThreads();
20389 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20390 wxPyEndAllowThreads(__tstate);
20391 if (PyErr_Occurred()) SWIG_fail;
20392 }
20393 {
20394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20395 }
20396 return resultobj;
20397 fail:
20398 return NULL;
20399 }
20400
20401
20402 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20403 PyObject *resultobj = 0;
20404 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20405 bool result;
20406 void *argp1 = 0 ;
20407 int res1 = 0 ;
20408 PyObject *swig_obj[1] ;
20409
20410 if (!args) SWIG_fail;
20411 swig_obj[0] = args;
20412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20413 if (!SWIG_IsOK(res1)) {
20414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20415 }
20416 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20417 {
20418 PyThreadState* __tstate = wxPyBeginAllowThreads();
20419 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20420 wxPyEndAllowThreads(__tstate);
20421 if (PyErr_Occurred()) SWIG_fail;
20422 }
20423 {
20424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20425 }
20426 return resultobj;
20427 fail:
20428 return NULL;
20429 }
20430
20431
20432 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20433 PyObject *resultobj = 0;
20434 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20435 bool result;
20436 void *argp1 = 0 ;
20437 int res1 = 0 ;
20438 PyObject *swig_obj[1] ;
20439
20440 if (!args) SWIG_fail;
20441 swig_obj[0] = args;
20442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20443 if (!SWIG_IsOK(res1)) {
20444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20445 }
20446 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20447 {
20448 PyThreadState* __tstate = wxPyBeginAllowThreads();
20449 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20450 wxPyEndAllowThreads(__tstate);
20451 if (PyErr_Occurred()) SWIG_fail;
20452 }
20453 {
20454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20455 }
20456 return resultobj;
20457 fail:
20458 return NULL;
20459 }
20460
20461
20462 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20463 PyObject *resultobj = 0;
20464 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20465 bool result;
20466 void *argp1 = 0 ;
20467 int res1 = 0 ;
20468 PyObject *swig_obj[1] ;
20469
20470 if (!args) SWIG_fail;
20471 swig_obj[0] = args;
20472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20473 if (!SWIG_IsOK(res1)) {
20474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20475 }
20476 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20477 {
20478 PyThreadState* __tstate = wxPyBeginAllowThreads();
20479 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20480 wxPyEndAllowThreads(__tstate);
20481 if (PyErr_Occurred()) SWIG_fail;
20482 }
20483 {
20484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20485 }
20486 return resultobj;
20487 fail:
20488 return NULL;
20489 }
20490
20491
20492 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20493 PyObject *resultobj = 0;
20494 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20495 bool result;
20496 void *argp1 = 0 ;
20497 int res1 = 0 ;
20498 PyObject *swig_obj[1] ;
20499
20500 if (!args) SWIG_fail;
20501 swig_obj[0] = args;
20502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20503 if (!SWIG_IsOK(res1)) {
20504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20505 }
20506 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20507 {
20508 PyThreadState* __tstate = wxPyBeginAllowThreads();
20509 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20510 wxPyEndAllowThreads(__tstate);
20511 if (PyErr_Occurred()) SWIG_fail;
20512 }
20513 {
20514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20515 }
20516 return resultobj;
20517 fail:
20518 return NULL;
20519 }
20520
20521
20522 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20523 PyObject *resultobj = 0;
20524 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20525 bool result;
20526 void *argp1 = 0 ;
20527 int res1 = 0 ;
20528 PyObject *swig_obj[1] ;
20529
20530 if (!args) SWIG_fail;
20531 swig_obj[0] = args;
20532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20533 if (!SWIG_IsOK(res1)) {
20534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20535 }
20536 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20537 {
20538 PyThreadState* __tstate = wxPyBeginAllowThreads();
20539 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20540 wxPyEndAllowThreads(__tstate);
20541 if (PyErr_Occurred()) SWIG_fail;
20542 }
20543 {
20544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20545 }
20546 return resultobj;
20547 fail:
20548 return NULL;
20549 }
20550
20551
20552 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20553 PyObject *resultobj = 0;
20554 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20555 bool result;
20556 void *argp1 = 0 ;
20557 int res1 = 0 ;
20558 PyObject *swig_obj[1] ;
20559
20560 if (!args) SWIG_fail;
20561 swig_obj[0] = args;
20562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20563 if (!SWIG_IsOK(res1)) {
20564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20565 }
20566 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20567 {
20568 PyThreadState* __tstate = wxPyBeginAllowThreads();
20569 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20570 wxPyEndAllowThreads(__tstate);
20571 if (PyErr_Occurred()) SWIG_fail;
20572 }
20573 {
20574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20575 }
20576 return resultobj;
20577 fail:
20578 return NULL;
20579 }
20580
20581
20582 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20583 PyObject *resultobj = 0;
20584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20585 bool result;
20586 void *argp1 = 0 ;
20587 int res1 = 0 ;
20588 PyObject *swig_obj[1] ;
20589
20590 if (!args) SWIG_fail;
20591 swig_obj[0] = args;
20592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20593 if (!SWIG_IsOK(res1)) {
20594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20595 }
20596 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20600 wxPyEndAllowThreads(__tstate);
20601 if (PyErr_Occurred()) SWIG_fail;
20602 }
20603 {
20604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20605 }
20606 return resultobj;
20607 fail:
20608 return NULL;
20609 }
20610
20611
20612 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20613 PyObject *resultobj = 0;
20614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20615 bool result;
20616 void *argp1 = 0 ;
20617 int res1 = 0 ;
20618 PyObject *swig_obj[1] ;
20619
20620 if (!args) SWIG_fail;
20621 swig_obj[0] = args;
20622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20623 if (!SWIG_IsOK(res1)) {
20624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20625 }
20626 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20627 {
20628 PyThreadState* __tstate = wxPyBeginAllowThreads();
20629 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20630 wxPyEndAllowThreads(__tstate);
20631 if (PyErr_Occurred()) SWIG_fail;
20632 }
20633 {
20634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20635 }
20636 return resultobj;
20637 fail:
20638 return NULL;
20639 }
20640
20641
20642 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20643 PyObject *resultobj = 0;
20644 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20645 bool result;
20646 void *argp1 = 0 ;
20647 int res1 = 0 ;
20648 PyObject *swig_obj[1] ;
20649
20650 if (!args) SWIG_fail;
20651 swig_obj[0] = args;
20652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20653 if (!SWIG_IsOK(res1)) {
20654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20655 }
20656 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20657 {
20658 PyThreadState* __tstate = wxPyBeginAllowThreads();
20659 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20660 wxPyEndAllowThreads(__tstate);
20661 if (PyErr_Occurred()) SWIG_fail;
20662 }
20663 {
20664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20665 }
20666 return resultobj;
20667 fail:
20668 return NULL;
20669 }
20670
20671
20672 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20673 PyObject *resultobj = 0;
20674 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20675 bool result;
20676 void *argp1 = 0 ;
20677 int res1 = 0 ;
20678 PyObject *swig_obj[1] ;
20679
20680 if (!args) SWIG_fail;
20681 swig_obj[0] = args;
20682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20683 if (!SWIG_IsOK(res1)) {
20684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20685 }
20686 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20687 {
20688 PyThreadState* __tstate = wxPyBeginAllowThreads();
20689 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20690 wxPyEndAllowThreads(__tstate);
20691 if (PyErr_Occurred()) SWIG_fail;
20692 }
20693 {
20694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20695 }
20696 return resultobj;
20697 fail:
20698 return NULL;
20699 }
20700
20701
20702 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20703 PyObject *resultobj = 0;
20704 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20705 bool result;
20706 void *argp1 = 0 ;
20707 int res1 = 0 ;
20708 PyObject *swig_obj[1] ;
20709
20710 if (!args) SWIG_fail;
20711 swig_obj[0] = args;
20712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20713 if (!SWIG_IsOK(res1)) {
20714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20715 }
20716 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20717 {
20718 PyThreadState* __tstate = wxPyBeginAllowThreads();
20719 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20720 wxPyEndAllowThreads(__tstate);
20721 if (PyErr_Occurred()) SWIG_fail;
20722 }
20723 {
20724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20725 }
20726 return resultobj;
20727 fail:
20728 return NULL;
20729 }
20730
20731
20732 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20733 PyObject *resultobj = 0;
20734 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20735 bool result;
20736 void *argp1 = 0 ;
20737 int res1 = 0 ;
20738 PyObject *swig_obj[1] ;
20739
20740 if (!args) SWIG_fail;
20741 swig_obj[0] = args;
20742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20743 if (!SWIG_IsOK(res1)) {
20744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20745 }
20746 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20747 {
20748 PyThreadState* __tstate = wxPyBeginAllowThreads();
20749 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20750 wxPyEndAllowThreads(__tstate);
20751 if (PyErr_Occurred()) SWIG_fail;
20752 }
20753 {
20754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20755 }
20756 return resultobj;
20757 fail:
20758 return NULL;
20759 }
20760
20761
20762 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20763 PyObject *resultobj = 0;
20764 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20765 bool result;
20766 void *argp1 = 0 ;
20767 int res1 = 0 ;
20768 PyObject *swig_obj[1] ;
20769
20770 if (!args) SWIG_fail;
20771 swig_obj[0] = args;
20772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20773 if (!SWIG_IsOK(res1)) {
20774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20775 }
20776 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20777 {
20778 PyThreadState* __tstate = wxPyBeginAllowThreads();
20779 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20780 wxPyEndAllowThreads(__tstate);
20781 if (PyErr_Occurred()) SWIG_fail;
20782 }
20783 {
20784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20785 }
20786 return resultobj;
20787 fail:
20788 return NULL;
20789 }
20790
20791
20792 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20793 PyObject *resultobj = 0;
20794 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20795 bool result;
20796 void *argp1 = 0 ;
20797 int res1 = 0 ;
20798 PyObject *swig_obj[1] ;
20799
20800 if (!args) SWIG_fail;
20801 swig_obj[0] = args;
20802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20803 if (!SWIG_IsOK(res1)) {
20804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20805 }
20806 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20807 {
20808 PyThreadState* __tstate = wxPyBeginAllowThreads();
20809 result = (bool)(arg1)->LeftIsDown();
20810 wxPyEndAllowThreads(__tstate);
20811 if (PyErr_Occurred()) SWIG_fail;
20812 }
20813 {
20814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20815 }
20816 return resultobj;
20817 fail:
20818 return NULL;
20819 }
20820
20821
20822 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20823 PyObject *resultobj = 0;
20824 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20825 bool result;
20826 void *argp1 = 0 ;
20827 int res1 = 0 ;
20828 PyObject *swig_obj[1] ;
20829
20830 if (!args) SWIG_fail;
20831 swig_obj[0] = args;
20832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20833 if (!SWIG_IsOK(res1)) {
20834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20835 }
20836 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20837 {
20838 PyThreadState* __tstate = wxPyBeginAllowThreads();
20839 result = (bool)(arg1)->MiddleIsDown();
20840 wxPyEndAllowThreads(__tstate);
20841 if (PyErr_Occurred()) SWIG_fail;
20842 }
20843 {
20844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20845 }
20846 return resultobj;
20847 fail:
20848 return NULL;
20849 }
20850
20851
20852 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20853 PyObject *resultobj = 0;
20854 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20855 bool result;
20856 void *argp1 = 0 ;
20857 int res1 = 0 ;
20858 PyObject *swig_obj[1] ;
20859
20860 if (!args) SWIG_fail;
20861 swig_obj[0] = args;
20862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20863 if (!SWIG_IsOK(res1)) {
20864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20865 }
20866 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20867 {
20868 PyThreadState* __tstate = wxPyBeginAllowThreads();
20869 result = (bool)(arg1)->RightIsDown();
20870 wxPyEndAllowThreads(__tstate);
20871 if (PyErr_Occurred()) SWIG_fail;
20872 }
20873 {
20874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20875 }
20876 return resultobj;
20877 fail:
20878 return NULL;
20879 }
20880
20881
20882 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20883 PyObject *resultobj = 0;
20884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20885 bool result;
20886 void *argp1 = 0 ;
20887 int res1 = 0 ;
20888 PyObject *swig_obj[1] ;
20889
20890 if (!args) SWIG_fail;
20891 swig_obj[0] = args;
20892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20893 if (!SWIG_IsOK(res1)) {
20894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20895 }
20896 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20897 {
20898 PyThreadState* __tstate = wxPyBeginAllowThreads();
20899 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20900 wxPyEndAllowThreads(__tstate);
20901 if (PyErr_Occurred()) SWIG_fail;
20902 }
20903 {
20904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20905 }
20906 return resultobj;
20907 fail:
20908 return NULL;
20909 }
20910
20911
20912 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20913 PyObject *resultobj = 0;
20914 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20915 bool result;
20916 void *argp1 = 0 ;
20917 int res1 = 0 ;
20918 PyObject *swig_obj[1] ;
20919
20920 if (!args) SWIG_fail;
20921 swig_obj[0] = args;
20922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20923 if (!SWIG_IsOK(res1)) {
20924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20925 }
20926 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20927 {
20928 PyThreadState* __tstate = wxPyBeginAllowThreads();
20929 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20930 wxPyEndAllowThreads(__tstate);
20931 if (PyErr_Occurred()) SWIG_fail;
20932 }
20933 {
20934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20935 }
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20943 PyObject *resultobj = 0;
20944 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20945 bool result;
20946 void *argp1 = 0 ;
20947 int res1 = 0 ;
20948 PyObject *swig_obj[1] ;
20949
20950 if (!args) SWIG_fail;
20951 swig_obj[0] = args;
20952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20953 if (!SWIG_IsOK(res1)) {
20954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20955 }
20956 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20957 {
20958 PyThreadState* __tstate = wxPyBeginAllowThreads();
20959 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20960 wxPyEndAllowThreads(__tstate);
20961 if (PyErr_Occurred()) SWIG_fail;
20962 }
20963 {
20964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20965 }
20966 return resultobj;
20967 fail:
20968 return NULL;
20969 }
20970
20971
20972 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20973 PyObject *resultobj = 0;
20974 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20975 bool result;
20976 void *argp1 = 0 ;
20977 int res1 = 0 ;
20978 PyObject *swig_obj[1] ;
20979
20980 if (!args) SWIG_fail;
20981 swig_obj[0] = args;
20982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20983 if (!SWIG_IsOK(res1)) {
20984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20985 }
20986 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20987 {
20988 PyThreadState* __tstate = wxPyBeginAllowThreads();
20989 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20990 wxPyEndAllowThreads(__tstate);
20991 if (PyErr_Occurred()) SWIG_fail;
20992 }
20993 {
20994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20995 }
20996 return resultobj;
20997 fail:
20998 return NULL;
20999 }
21000
21001
21002 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21003 PyObject *resultobj = 0;
21004 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21005 wxPoint result;
21006 void *argp1 = 0 ;
21007 int res1 = 0 ;
21008 PyObject *swig_obj[1] ;
21009
21010 if (!args) SWIG_fail;
21011 swig_obj[0] = args;
21012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21013 if (!SWIG_IsOK(res1)) {
21014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21015 }
21016 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21017 {
21018 PyThreadState* __tstate = wxPyBeginAllowThreads();
21019 result = (arg1)->GetPosition();
21020 wxPyEndAllowThreads(__tstate);
21021 if (PyErr_Occurred()) SWIG_fail;
21022 }
21023 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21024 return resultobj;
21025 fail:
21026 return NULL;
21027 }
21028
21029
21030 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21031 PyObject *resultobj = 0;
21032 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21033 long *arg2 = (long *) 0 ;
21034 long *arg3 = (long *) 0 ;
21035 void *argp1 = 0 ;
21036 int res1 = 0 ;
21037 long temp2 ;
21038 int res2 = SWIG_TMPOBJ ;
21039 long temp3 ;
21040 int res3 = SWIG_TMPOBJ ;
21041 PyObject *swig_obj[1] ;
21042
21043 arg2 = &temp2;
21044 arg3 = &temp3;
21045 if (!args) SWIG_fail;
21046 swig_obj[0] = args;
21047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21048 if (!SWIG_IsOK(res1)) {
21049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21050 }
21051 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21052 {
21053 PyThreadState* __tstate = wxPyBeginAllowThreads();
21054 (arg1)->GetPosition(arg2,arg3);
21055 wxPyEndAllowThreads(__tstate);
21056 if (PyErr_Occurred()) SWIG_fail;
21057 }
21058 resultobj = SWIG_Py_Void();
21059 if (SWIG_IsTmpObj(res2)) {
21060 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
21061 } else {
21062 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21063 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
21064 }
21065 if (SWIG_IsTmpObj(res3)) {
21066 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
21067 } else {
21068 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
21069 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
21070 }
21071 return resultobj;
21072 fail:
21073 return NULL;
21074 }
21075
21076
21077 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21078 PyObject *resultobj = 0;
21079 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21080 wxDC *arg2 = 0 ;
21081 wxPoint result;
21082 void *argp1 = 0 ;
21083 int res1 = 0 ;
21084 void *argp2 = 0 ;
21085 int res2 = 0 ;
21086 PyObject * obj0 = 0 ;
21087 PyObject * obj1 = 0 ;
21088 char * kwnames[] = {
21089 (char *) "self",(char *) "dc", NULL
21090 };
21091
21092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
21093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21094 if (!SWIG_IsOK(res1)) {
21095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21096 }
21097 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
21099 if (!SWIG_IsOK(res2)) {
21100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21101 }
21102 if (!argp2) {
21103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
21104 }
21105 arg2 = reinterpret_cast< wxDC * >(argp2);
21106 {
21107 PyThreadState* __tstate = wxPyBeginAllowThreads();
21108 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
21109 wxPyEndAllowThreads(__tstate);
21110 if (PyErr_Occurred()) SWIG_fail;
21111 }
21112 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
21113 return resultobj;
21114 fail:
21115 return NULL;
21116 }
21117
21118
21119 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21120 PyObject *resultobj = 0;
21121 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21122 int result;
21123 void *argp1 = 0 ;
21124 int res1 = 0 ;
21125 PyObject *swig_obj[1] ;
21126
21127 if (!args) SWIG_fail;
21128 swig_obj[0] = args;
21129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21130 if (!SWIG_IsOK(res1)) {
21131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21132 }
21133 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 result = (int)((wxMouseEvent const *)arg1)->GetX();
21137 wxPyEndAllowThreads(__tstate);
21138 if (PyErr_Occurred()) SWIG_fail;
21139 }
21140 resultobj = SWIG_From_int(static_cast< int >(result));
21141 return resultobj;
21142 fail:
21143 return NULL;
21144 }
21145
21146
21147 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21148 PyObject *resultobj = 0;
21149 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21150 int result;
21151 void *argp1 = 0 ;
21152 int res1 = 0 ;
21153 PyObject *swig_obj[1] ;
21154
21155 if (!args) SWIG_fail;
21156 swig_obj[0] = args;
21157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21158 if (!SWIG_IsOK(res1)) {
21159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21160 }
21161 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21162 {
21163 PyThreadState* __tstate = wxPyBeginAllowThreads();
21164 result = (int)((wxMouseEvent const *)arg1)->GetY();
21165 wxPyEndAllowThreads(__tstate);
21166 if (PyErr_Occurred()) SWIG_fail;
21167 }
21168 resultobj = SWIG_From_int(static_cast< int >(result));
21169 return resultobj;
21170 fail:
21171 return NULL;
21172 }
21173
21174
21175 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21176 PyObject *resultobj = 0;
21177 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21178 int result;
21179 void *argp1 = 0 ;
21180 int res1 = 0 ;
21181 PyObject *swig_obj[1] ;
21182
21183 if (!args) SWIG_fail;
21184 swig_obj[0] = args;
21185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21186 if (!SWIG_IsOK(res1)) {
21187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21188 }
21189 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21190 {
21191 PyThreadState* __tstate = wxPyBeginAllowThreads();
21192 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
21193 wxPyEndAllowThreads(__tstate);
21194 if (PyErr_Occurred()) SWIG_fail;
21195 }
21196 resultobj = SWIG_From_int(static_cast< int >(result));
21197 return resultobj;
21198 fail:
21199 return NULL;
21200 }
21201
21202
21203 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21204 PyObject *resultobj = 0;
21205 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21206 int result;
21207 void *argp1 = 0 ;
21208 int res1 = 0 ;
21209 PyObject *swig_obj[1] ;
21210
21211 if (!args) SWIG_fail;
21212 swig_obj[0] = args;
21213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21214 if (!SWIG_IsOK(res1)) {
21215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21216 }
21217 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21218 {
21219 PyThreadState* __tstate = wxPyBeginAllowThreads();
21220 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21221 wxPyEndAllowThreads(__tstate);
21222 if (PyErr_Occurred()) SWIG_fail;
21223 }
21224 resultobj = SWIG_From_int(static_cast< int >(result));
21225 return resultobj;
21226 fail:
21227 return NULL;
21228 }
21229
21230
21231 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21232 PyObject *resultobj = 0;
21233 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21234 int result;
21235 void *argp1 = 0 ;
21236 int res1 = 0 ;
21237 PyObject *swig_obj[1] ;
21238
21239 if (!args) SWIG_fail;
21240 swig_obj[0] = args;
21241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21242 if (!SWIG_IsOK(res1)) {
21243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21244 }
21245 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21246 {
21247 PyThreadState* __tstate = wxPyBeginAllowThreads();
21248 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21249 wxPyEndAllowThreads(__tstate);
21250 if (PyErr_Occurred()) SWIG_fail;
21251 }
21252 resultobj = SWIG_From_int(static_cast< int >(result));
21253 return resultobj;
21254 fail:
21255 return NULL;
21256 }
21257
21258
21259 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21260 PyObject *resultobj = 0;
21261 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21262 bool result;
21263 void *argp1 = 0 ;
21264 int res1 = 0 ;
21265 PyObject *swig_obj[1] ;
21266
21267 if (!args) SWIG_fail;
21268 swig_obj[0] = args;
21269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21270 if (!SWIG_IsOK(res1)) {
21271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21272 }
21273 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21274 {
21275 PyThreadState* __tstate = wxPyBeginAllowThreads();
21276 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21277 wxPyEndAllowThreads(__tstate);
21278 if (PyErr_Occurred()) SWIG_fail;
21279 }
21280 {
21281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21282 }
21283 return resultobj;
21284 fail:
21285 return NULL;
21286 }
21287
21288
21289 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21290 PyObject *resultobj = 0;
21291 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21292 int arg2 ;
21293 void *argp1 = 0 ;
21294 int res1 = 0 ;
21295 int val2 ;
21296 int ecode2 = 0 ;
21297 PyObject *swig_obj[2] ;
21298
21299 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21301 if (!SWIG_IsOK(res1)) {
21302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21303 }
21304 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21305 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21306 if (!SWIG_IsOK(ecode2)) {
21307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21308 }
21309 arg2 = static_cast< int >(val2);
21310 if (arg1) (arg1)->m_x = arg2;
21311
21312 resultobj = SWIG_Py_Void();
21313 return resultobj;
21314 fail:
21315 return NULL;
21316 }
21317
21318
21319 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21320 PyObject *resultobj = 0;
21321 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21322 int result;
21323 void *argp1 = 0 ;
21324 int res1 = 0 ;
21325 PyObject *swig_obj[1] ;
21326
21327 if (!args) SWIG_fail;
21328 swig_obj[0] = args;
21329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21330 if (!SWIG_IsOK(res1)) {
21331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21332 }
21333 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21334 result = (int) ((arg1)->m_x);
21335 resultobj = SWIG_From_int(static_cast< int >(result));
21336 return resultobj;
21337 fail:
21338 return NULL;
21339 }
21340
21341
21342 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21343 PyObject *resultobj = 0;
21344 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21345 int arg2 ;
21346 void *argp1 = 0 ;
21347 int res1 = 0 ;
21348 int val2 ;
21349 int ecode2 = 0 ;
21350 PyObject *swig_obj[2] ;
21351
21352 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21354 if (!SWIG_IsOK(res1)) {
21355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21356 }
21357 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21358 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21359 if (!SWIG_IsOK(ecode2)) {
21360 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21361 }
21362 arg2 = static_cast< int >(val2);
21363 if (arg1) (arg1)->m_y = arg2;
21364
21365 resultobj = SWIG_Py_Void();
21366 return resultobj;
21367 fail:
21368 return NULL;
21369 }
21370
21371
21372 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21373 PyObject *resultobj = 0;
21374 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21375 int result;
21376 void *argp1 = 0 ;
21377 int res1 = 0 ;
21378 PyObject *swig_obj[1] ;
21379
21380 if (!args) SWIG_fail;
21381 swig_obj[0] = args;
21382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21383 if (!SWIG_IsOK(res1)) {
21384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21385 }
21386 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21387 result = (int) ((arg1)->m_y);
21388 resultobj = SWIG_From_int(static_cast< int >(result));
21389 return resultobj;
21390 fail:
21391 return NULL;
21392 }
21393
21394
21395 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21396 PyObject *resultobj = 0;
21397 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21398 bool arg2 ;
21399 void *argp1 = 0 ;
21400 int res1 = 0 ;
21401 bool val2 ;
21402 int ecode2 = 0 ;
21403 PyObject *swig_obj[2] ;
21404
21405 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21407 if (!SWIG_IsOK(res1)) {
21408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21409 }
21410 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21411 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21412 if (!SWIG_IsOK(ecode2)) {
21413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21414 }
21415 arg2 = static_cast< bool >(val2);
21416 if (arg1) (arg1)->m_leftDown = arg2;
21417
21418 resultobj = SWIG_Py_Void();
21419 return resultobj;
21420 fail:
21421 return NULL;
21422 }
21423
21424
21425 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21426 PyObject *resultobj = 0;
21427 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21428 bool result;
21429 void *argp1 = 0 ;
21430 int res1 = 0 ;
21431 PyObject *swig_obj[1] ;
21432
21433 if (!args) SWIG_fail;
21434 swig_obj[0] = args;
21435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21436 if (!SWIG_IsOK(res1)) {
21437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21438 }
21439 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21440 result = (bool) ((arg1)->m_leftDown);
21441 {
21442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21443 }
21444 return resultobj;
21445 fail:
21446 return NULL;
21447 }
21448
21449
21450 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21451 PyObject *resultobj = 0;
21452 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21453 bool arg2 ;
21454 void *argp1 = 0 ;
21455 int res1 = 0 ;
21456 bool val2 ;
21457 int ecode2 = 0 ;
21458 PyObject *swig_obj[2] ;
21459
21460 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21462 if (!SWIG_IsOK(res1)) {
21463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21464 }
21465 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21466 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21467 if (!SWIG_IsOK(ecode2)) {
21468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21469 }
21470 arg2 = static_cast< bool >(val2);
21471 if (arg1) (arg1)->m_middleDown = arg2;
21472
21473 resultobj = SWIG_Py_Void();
21474 return resultobj;
21475 fail:
21476 return NULL;
21477 }
21478
21479
21480 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21481 PyObject *resultobj = 0;
21482 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21483 bool result;
21484 void *argp1 = 0 ;
21485 int res1 = 0 ;
21486 PyObject *swig_obj[1] ;
21487
21488 if (!args) SWIG_fail;
21489 swig_obj[0] = args;
21490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21491 if (!SWIG_IsOK(res1)) {
21492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21493 }
21494 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21495 result = (bool) ((arg1)->m_middleDown);
21496 {
21497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21498 }
21499 return resultobj;
21500 fail:
21501 return NULL;
21502 }
21503
21504
21505 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21506 PyObject *resultobj = 0;
21507 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21508 bool arg2 ;
21509 void *argp1 = 0 ;
21510 int res1 = 0 ;
21511 bool val2 ;
21512 int ecode2 = 0 ;
21513 PyObject *swig_obj[2] ;
21514
21515 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21517 if (!SWIG_IsOK(res1)) {
21518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21519 }
21520 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21521 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21522 if (!SWIG_IsOK(ecode2)) {
21523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21524 }
21525 arg2 = static_cast< bool >(val2);
21526 if (arg1) (arg1)->m_rightDown = arg2;
21527
21528 resultobj = SWIG_Py_Void();
21529 return resultobj;
21530 fail:
21531 return NULL;
21532 }
21533
21534
21535 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21536 PyObject *resultobj = 0;
21537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21538 bool result;
21539 void *argp1 = 0 ;
21540 int res1 = 0 ;
21541 PyObject *swig_obj[1] ;
21542
21543 if (!args) SWIG_fail;
21544 swig_obj[0] = args;
21545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21546 if (!SWIG_IsOK(res1)) {
21547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21548 }
21549 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21550 result = (bool) ((arg1)->m_rightDown);
21551 {
21552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21553 }
21554 return resultobj;
21555 fail:
21556 return NULL;
21557 }
21558
21559
21560 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21561 PyObject *resultobj = 0;
21562 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21563 bool arg2 ;
21564 void *argp1 = 0 ;
21565 int res1 = 0 ;
21566 bool val2 ;
21567 int ecode2 = 0 ;
21568 PyObject *swig_obj[2] ;
21569
21570 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21572 if (!SWIG_IsOK(res1)) {
21573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21574 }
21575 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21576 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21577 if (!SWIG_IsOK(ecode2)) {
21578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21579 }
21580 arg2 = static_cast< bool >(val2);
21581 if (arg1) (arg1)->m_controlDown = arg2;
21582
21583 resultobj = SWIG_Py_Void();
21584 return resultobj;
21585 fail:
21586 return NULL;
21587 }
21588
21589
21590 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21591 PyObject *resultobj = 0;
21592 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21593 bool result;
21594 void *argp1 = 0 ;
21595 int res1 = 0 ;
21596 PyObject *swig_obj[1] ;
21597
21598 if (!args) SWIG_fail;
21599 swig_obj[0] = args;
21600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21601 if (!SWIG_IsOK(res1)) {
21602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21603 }
21604 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21605 result = (bool) ((arg1)->m_controlDown);
21606 {
21607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21608 }
21609 return resultobj;
21610 fail:
21611 return NULL;
21612 }
21613
21614
21615 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21616 PyObject *resultobj = 0;
21617 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21618 bool arg2 ;
21619 void *argp1 = 0 ;
21620 int res1 = 0 ;
21621 bool val2 ;
21622 int ecode2 = 0 ;
21623 PyObject *swig_obj[2] ;
21624
21625 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21627 if (!SWIG_IsOK(res1)) {
21628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21629 }
21630 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21631 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21632 if (!SWIG_IsOK(ecode2)) {
21633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21634 }
21635 arg2 = static_cast< bool >(val2);
21636 if (arg1) (arg1)->m_shiftDown = arg2;
21637
21638 resultobj = SWIG_Py_Void();
21639 return resultobj;
21640 fail:
21641 return NULL;
21642 }
21643
21644
21645 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21646 PyObject *resultobj = 0;
21647 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21648 bool result;
21649 void *argp1 = 0 ;
21650 int res1 = 0 ;
21651 PyObject *swig_obj[1] ;
21652
21653 if (!args) SWIG_fail;
21654 swig_obj[0] = args;
21655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21656 if (!SWIG_IsOK(res1)) {
21657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21658 }
21659 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21660 result = (bool) ((arg1)->m_shiftDown);
21661 {
21662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21663 }
21664 return resultobj;
21665 fail:
21666 return NULL;
21667 }
21668
21669
21670 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21671 PyObject *resultobj = 0;
21672 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21673 bool arg2 ;
21674 void *argp1 = 0 ;
21675 int res1 = 0 ;
21676 bool val2 ;
21677 int ecode2 = 0 ;
21678 PyObject *swig_obj[2] ;
21679
21680 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21682 if (!SWIG_IsOK(res1)) {
21683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21684 }
21685 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21686 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21687 if (!SWIG_IsOK(ecode2)) {
21688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21689 }
21690 arg2 = static_cast< bool >(val2);
21691 if (arg1) (arg1)->m_altDown = arg2;
21692
21693 resultobj = SWIG_Py_Void();
21694 return resultobj;
21695 fail:
21696 return NULL;
21697 }
21698
21699
21700 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21701 PyObject *resultobj = 0;
21702 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21703 bool result;
21704 void *argp1 = 0 ;
21705 int res1 = 0 ;
21706 PyObject *swig_obj[1] ;
21707
21708 if (!args) SWIG_fail;
21709 swig_obj[0] = args;
21710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21711 if (!SWIG_IsOK(res1)) {
21712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21713 }
21714 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21715 result = (bool) ((arg1)->m_altDown);
21716 {
21717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21718 }
21719 return resultobj;
21720 fail:
21721 return NULL;
21722 }
21723
21724
21725 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21726 PyObject *resultobj = 0;
21727 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21728 bool arg2 ;
21729 void *argp1 = 0 ;
21730 int res1 = 0 ;
21731 bool val2 ;
21732 int ecode2 = 0 ;
21733 PyObject *swig_obj[2] ;
21734
21735 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21737 if (!SWIG_IsOK(res1)) {
21738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21739 }
21740 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21741 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21742 if (!SWIG_IsOK(ecode2)) {
21743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21744 }
21745 arg2 = static_cast< bool >(val2);
21746 if (arg1) (arg1)->m_metaDown = arg2;
21747
21748 resultobj = SWIG_Py_Void();
21749 return resultobj;
21750 fail:
21751 return NULL;
21752 }
21753
21754
21755 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21756 PyObject *resultobj = 0;
21757 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21758 bool result;
21759 void *argp1 = 0 ;
21760 int res1 = 0 ;
21761 PyObject *swig_obj[1] ;
21762
21763 if (!args) SWIG_fail;
21764 swig_obj[0] = args;
21765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21766 if (!SWIG_IsOK(res1)) {
21767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21768 }
21769 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21770 result = (bool) ((arg1)->m_metaDown);
21771 {
21772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21773 }
21774 return resultobj;
21775 fail:
21776 return NULL;
21777 }
21778
21779
21780 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21781 PyObject *resultobj = 0;
21782 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21783 int arg2 ;
21784 void *argp1 = 0 ;
21785 int res1 = 0 ;
21786 int val2 ;
21787 int ecode2 = 0 ;
21788 PyObject *swig_obj[2] ;
21789
21790 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21792 if (!SWIG_IsOK(res1)) {
21793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21794 }
21795 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21796 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21797 if (!SWIG_IsOK(ecode2)) {
21798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21799 }
21800 arg2 = static_cast< int >(val2);
21801 if (arg1) (arg1)->m_wheelRotation = arg2;
21802
21803 resultobj = SWIG_Py_Void();
21804 return resultobj;
21805 fail:
21806 return NULL;
21807 }
21808
21809
21810 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21811 PyObject *resultobj = 0;
21812 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21813 int result;
21814 void *argp1 = 0 ;
21815 int res1 = 0 ;
21816 PyObject *swig_obj[1] ;
21817
21818 if (!args) SWIG_fail;
21819 swig_obj[0] = args;
21820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21821 if (!SWIG_IsOK(res1)) {
21822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21823 }
21824 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21825 result = (int) ((arg1)->m_wheelRotation);
21826 resultobj = SWIG_From_int(static_cast< int >(result));
21827 return resultobj;
21828 fail:
21829 return NULL;
21830 }
21831
21832
21833 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21834 PyObject *resultobj = 0;
21835 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21836 int arg2 ;
21837 void *argp1 = 0 ;
21838 int res1 = 0 ;
21839 int val2 ;
21840 int ecode2 = 0 ;
21841 PyObject *swig_obj[2] ;
21842
21843 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21845 if (!SWIG_IsOK(res1)) {
21846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21847 }
21848 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21849 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21850 if (!SWIG_IsOK(ecode2)) {
21851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21852 }
21853 arg2 = static_cast< int >(val2);
21854 if (arg1) (arg1)->m_wheelDelta = arg2;
21855
21856 resultobj = SWIG_Py_Void();
21857 return resultobj;
21858 fail:
21859 return NULL;
21860 }
21861
21862
21863 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21864 PyObject *resultobj = 0;
21865 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21866 int result;
21867 void *argp1 = 0 ;
21868 int res1 = 0 ;
21869 PyObject *swig_obj[1] ;
21870
21871 if (!args) SWIG_fail;
21872 swig_obj[0] = args;
21873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21874 if (!SWIG_IsOK(res1)) {
21875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21876 }
21877 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21878 result = (int) ((arg1)->m_wheelDelta);
21879 resultobj = SWIG_From_int(static_cast< int >(result));
21880 return resultobj;
21881 fail:
21882 return NULL;
21883 }
21884
21885
21886 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21887 PyObject *resultobj = 0;
21888 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21889 int arg2 ;
21890 void *argp1 = 0 ;
21891 int res1 = 0 ;
21892 int val2 ;
21893 int ecode2 = 0 ;
21894 PyObject *swig_obj[2] ;
21895
21896 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21898 if (!SWIG_IsOK(res1)) {
21899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21900 }
21901 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21902 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21903 if (!SWIG_IsOK(ecode2)) {
21904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21905 }
21906 arg2 = static_cast< int >(val2);
21907 if (arg1) (arg1)->m_linesPerAction = arg2;
21908
21909 resultobj = SWIG_Py_Void();
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21917 PyObject *resultobj = 0;
21918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21919 int result;
21920 void *argp1 = 0 ;
21921 int res1 = 0 ;
21922 PyObject *swig_obj[1] ;
21923
21924 if (!args) SWIG_fail;
21925 swig_obj[0] = args;
21926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21927 if (!SWIG_IsOK(res1)) {
21928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21929 }
21930 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21931 result = (int) ((arg1)->m_linesPerAction);
21932 resultobj = SWIG_From_int(static_cast< int >(result));
21933 return resultobj;
21934 fail:
21935 return NULL;
21936 }
21937
21938
21939 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21940 PyObject *obj;
21941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21942 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21943 return SWIG_Py_Void();
21944 }
21945
21946 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21947 return SWIG_Python_InitShadowInstance(args);
21948 }
21949
21950 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21951 PyObject *resultobj = 0;
21952 int arg1 = (int) 0 ;
21953 int arg2 = (int) 0 ;
21954 wxSetCursorEvent *result = 0 ;
21955 int val1 ;
21956 int ecode1 = 0 ;
21957 int val2 ;
21958 int ecode2 = 0 ;
21959 PyObject * obj0 = 0 ;
21960 PyObject * obj1 = 0 ;
21961 char * kwnames[] = {
21962 (char *) "x",(char *) "y", NULL
21963 };
21964
21965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21966 if (obj0) {
21967 ecode1 = SWIG_AsVal_int(obj0, &val1);
21968 if (!SWIG_IsOK(ecode1)) {
21969 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21970 }
21971 arg1 = static_cast< int >(val1);
21972 }
21973 if (obj1) {
21974 ecode2 = SWIG_AsVal_int(obj1, &val2);
21975 if (!SWIG_IsOK(ecode2)) {
21976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21977 }
21978 arg2 = static_cast< int >(val2);
21979 }
21980 {
21981 PyThreadState* __tstate = wxPyBeginAllowThreads();
21982 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21983 wxPyEndAllowThreads(__tstate);
21984 if (PyErr_Occurred()) SWIG_fail;
21985 }
21986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21987 return resultobj;
21988 fail:
21989 return NULL;
21990 }
21991
21992
21993 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21994 PyObject *resultobj = 0;
21995 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21996 int result;
21997 void *argp1 = 0 ;
21998 int res1 = 0 ;
21999 PyObject *swig_obj[1] ;
22000
22001 if (!args) SWIG_fail;
22002 swig_obj[0] = args;
22003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22004 if (!SWIG_IsOK(res1)) {
22005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22006 }
22007 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22008 {
22009 PyThreadState* __tstate = wxPyBeginAllowThreads();
22010 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
22011 wxPyEndAllowThreads(__tstate);
22012 if (PyErr_Occurred()) SWIG_fail;
22013 }
22014 resultobj = SWIG_From_int(static_cast< int >(result));
22015 return resultobj;
22016 fail:
22017 return NULL;
22018 }
22019
22020
22021 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22022 PyObject *resultobj = 0;
22023 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22024 int result;
22025 void *argp1 = 0 ;
22026 int res1 = 0 ;
22027 PyObject *swig_obj[1] ;
22028
22029 if (!args) SWIG_fail;
22030 swig_obj[0] = args;
22031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22032 if (!SWIG_IsOK(res1)) {
22033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22034 }
22035 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22036 {
22037 PyThreadState* __tstate = wxPyBeginAllowThreads();
22038 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
22039 wxPyEndAllowThreads(__tstate);
22040 if (PyErr_Occurred()) SWIG_fail;
22041 }
22042 resultobj = SWIG_From_int(static_cast< int >(result));
22043 return resultobj;
22044 fail:
22045 return NULL;
22046 }
22047
22048
22049 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22050 PyObject *resultobj = 0;
22051 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22052 wxCursor *arg2 = 0 ;
22053 void *argp1 = 0 ;
22054 int res1 = 0 ;
22055 void *argp2 = 0 ;
22056 int res2 = 0 ;
22057 PyObject * obj0 = 0 ;
22058 PyObject * obj1 = 0 ;
22059 char * kwnames[] = {
22060 (char *) "self",(char *) "cursor", NULL
22061 };
22062
22063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
22064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22065 if (!SWIG_IsOK(res1)) {
22066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
22067 }
22068 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22069 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
22070 if (!SWIG_IsOK(res2)) {
22071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22072 }
22073 if (!argp2) {
22074 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
22075 }
22076 arg2 = reinterpret_cast< wxCursor * >(argp2);
22077 {
22078 PyThreadState* __tstate = wxPyBeginAllowThreads();
22079 (arg1)->SetCursor((wxCursor const &)*arg2);
22080 wxPyEndAllowThreads(__tstate);
22081 if (PyErr_Occurred()) SWIG_fail;
22082 }
22083 resultobj = SWIG_Py_Void();
22084 return resultobj;
22085 fail:
22086 return NULL;
22087 }
22088
22089
22090 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22091 PyObject *resultobj = 0;
22092 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22093 wxCursor *result = 0 ;
22094 void *argp1 = 0 ;
22095 int res1 = 0 ;
22096 PyObject *swig_obj[1] ;
22097
22098 if (!args) SWIG_fail;
22099 swig_obj[0] = args;
22100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22101 if (!SWIG_IsOK(res1)) {
22102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22103 }
22104 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22105 {
22106 PyThreadState* __tstate = wxPyBeginAllowThreads();
22107 {
22108 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
22109 result = (wxCursor *) &_result_ref;
22110 }
22111 wxPyEndAllowThreads(__tstate);
22112 if (PyErr_Occurred()) SWIG_fail;
22113 }
22114 {
22115 wxCursor* resultptr = new wxCursor(*result);
22116 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
22117 }
22118 return resultobj;
22119 fail:
22120 return NULL;
22121 }
22122
22123
22124 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22125 PyObject *resultobj = 0;
22126 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
22127 bool result;
22128 void *argp1 = 0 ;
22129 int res1 = 0 ;
22130 PyObject *swig_obj[1] ;
22131
22132 if (!args) SWIG_fail;
22133 swig_obj[0] = args;
22134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
22135 if (!SWIG_IsOK(res1)) {
22136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
22137 }
22138 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
22139 {
22140 PyThreadState* __tstate = wxPyBeginAllowThreads();
22141 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
22142 wxPyEndAllowThreads(__tstate);
22143 if (PyErr_Occurred()) SWIG_fail;
22144 }
22145 {
22146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22147 }
22148 return resultobj;
22149 fail:
22150 return NULL;
22151 }
22152
22153
22154 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22155 PyObject *obj;
22156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22157 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
22158 return SWIG_Py_Void();
22159 }
22160
22161 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22162 return SWIG_Python_InitShadowInstance(args);
22163 }
22164
22165 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22166 PyObject *resultobj = 0;
22167 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22168 wxKeyEvent *result = 0 ;
22169 int val1 ;
22170 int ecode1 = 0 ;
22171 PyObject * obj0 = 0 ;
22172 char * kwnames[] = {
22173 (char *) "eventType", NULL
22174 };
22175
22176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
22177 if (obj0) {
22178 ecode1 = SWIG_AsVal_int(obj0, &val1);
22179 if (!SWIG_IsOK(ecode1)) {
22180 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22181 }
22182 arg1 = static_cast< wxEventType >(val1);
22183 }
22184 {
22185 PyThreadState* __tstate = wxPyBeginAllowThreads();
22186 result = (wxKeyEvent *)new wxKeyEvent(arg1);
22187 wxPyEndAllowThreads(__tstate);
22188 if (PyErr_Occurred()) SWIG_fail;
22189 }
22190 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
22191 return resultobj;
22192 fail:
22193 return NULL;
22194 }
22195
22196
22197 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22198 PyObject *resultobj = 0;
22199 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22200 int result;
22201 void *argp1 = 0 ;
22202 int res1 = 0 ;
22203 PyObject *swig_obj[1] ;
22204
22205 if (!args) SWIG_fail;
22206 swig_obj[0] = args;
22207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22208 if (!SWIG_IsOK(res1)) {
22209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22210 }
22211 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22212 {
22213 PyThreadState* __tstate = wxPyBeginAllowThreads();
22214 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22215 wxPyEndAllowThreads(__tstate);
22216 if (PyErr_Occurred()) SWIG_fail;
22217 }
22218 resultobj = SWIG_From_int(static_cast< int >(result));
22219 return resultobj;
22220 fail:
22221 return NULL;
22222 }
22223
22224
22225 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22226 PyObject *resultobj = 0;
22227 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22228 bool result;
22229 void *argp1 = 0 ;
22230 int res1 = 0 ;
22231 PyObject *swig_obj[1] ;
22232
22233 if (!args) SWIG_fail;
22234 swig_obj[0] = args;
22235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22236 if (!SWIG_IsOK(res1)) {
22237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22238 }
22239 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22240 {
22241 PyThreadState* __tstate = wxPyBeginAllowThreads();
22242 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22243 wxPyEndAllowThreads(__tstate);
22244 if (PyErr_Occurred()) SWIG_fail;
22245 }
22246 {
22247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22248 }
22249 return resultobj;
22250 fail:
22251 return NULL;
22252 }
22253
22254
22255 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22256 PyObject *resultobj = 0;
22257 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22258 bool result;
22259 void *argp1 = 0 ;
22260 int res1 = 0 ;
22261 PyObject *swig_obj[1] ;
22262
22263 if (!args) SWIG_fail;
22264 swig_obj[0] = args;
22265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22266 if (!SWIG_IsOK(res1)) {
22267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22268 }
22269 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22270 {
22271 PyThreadState* __tstate = wxPyBeginAllowThreads();
22272 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22273 wxPyEndAllowThreads(__tstate);
22274 if (PyErr_Occurred()) SWIG_fail;
22275 }
22276 {
22277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22278 }
22279 return resultobj;
22280 fail:
22281 return NULL;
22282 }
22283
22284
22285 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22286 PyObject *resultobj = 0;
22287 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22288 bool result;
22289 void *argp1 = 0 ;
22290 int res1 = 0 ;
22291 PyObject *swig_obj[1] ;
22292
22293 if (!args) SWIG_fail;
22294 swig_obj[0] = args;
22295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22296 if (!SWIG_IsOK(res1)) {
22297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22298 }
22299 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22300 {
22301 PyThreadState* __tstate = wxPyBeginAllowThreads();
22302 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22303 wxPyEndAllowThreads(__tstate);
22304 if (PyErr_Occurred()) SWIG_fail;
22305 }
22306 {
22307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22308 }
22309 return resultobj;
22310 fail:
22311 return NULL;
22312 }
22313
22314
22315 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22316 PyObject *resultobj = 0;
22317 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22318 bool result;
22319 void *argp1 = 0 ;
22320 int res1 = 0 ;
22321 PyObject *swig_obj[1] ;
22322
22323 if (!args) SWIG_fail;
22324 swig_obj[0] = args;
22325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22326 if (!SWIG_IsOK(res1)) {
22327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22328 }
22329 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22330 {
22331 PyThreadState* __tstate = wxPyBeginAllowThreads();
22332 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22333 wxPyEndAllowThreads(__tstate);
22334 if (PyErr_Occurred()) SWIG_fail;
22335 }
22336 {
22337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22338 }
22339 return resultobj;
22340 fail:
22341 return NULL;
22342 }
22343
22344
22345 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22346 PyObject *resultobj = 0;
22347 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22348 bool result;
22349 void *argp1 = 0 ;
22350 int res1 = 0 ;
22351 PyObject *swig_obj[1] ;
22352
22353 if (!args) SWIG_fail;
22354 swig_obj[0] = args;
22355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22356 if (!SWIG_IsOK(res1)) {
22357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22358 }
22359 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22360 {
22361 PyThreadState* __tstate = wxPyBeginAllowThreads();
22362 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22363 wxPyEndAllowThreads(__tstate);
22364 if (PyErr_Occurred()) SWIG_fail;
22365 }
22366 {
22367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22368 }
22369 return resultobj;
22370 fail:
22371 return NULL;
22372 }
22373
22374
22375 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22376 PyObject *resultobj = 0;
22377 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22378 bool result;
22379 void *argp1 = 0 ;
22380 int res1 = 0 ;
22381 PyObject *swig_obj[1] ;
22382
22383 if (!args) SWIG_fail;
22384 swig_obj[0] = args;
22385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22386 if (!SWIG_IsOK(res1)) {
22387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22388 }
22389 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22390 {
22391 PyThreadState* __tstate = wxPyBeginAllowThreads();
22392 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22393 wxPyEndAllowThreads(__tstate);
22394 if (PyErr_Occurred()) SWIG_fail;
22395 }
22396 {
22397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22398 }
22399 return resultobj;
22400 fail:
22401 return NULL;
22402 }
22403
22404
22405 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22406 PyObject *resultobj = 0;
22407 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22408 int result;
22409 void *argp1 = 0 ;
22410 int res1 = 0 ;
22411 PyObject *swig_obj[1] ;
22412
22413 if (!args) SWIG_fail;
22414 swig_obj[0] = args;
22415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22416 if (!SWIG_IsOK(res1)) {
22417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22418 }
22419 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22420 {
22421 PyThreadState* __tstate = wxPyBeginAllowThreads();
22422 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22423 wxPyEndAllowThreads(__tstate);
22424 if (PyErr_Occurred()) SWIG_fail;
22425 }
22426 resultobj = SWIG_From_int(static_cast< int >(result));
22427 return resultobj;
22428 fail:
22429 return NULL;
22430 }
22431
22432
22433 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22434 PyObject *resultobj = 0;
22435 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22436 int result;
22437 void *argp1 = 0 ;
22438 int res1 = 0 ;
22439 PyObject *swig_obj[1] ;
22440
22441 if (!args) SWIG_fail;
22442 swig_obj[0] = args;
22443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22444 if (!SWIG_IsOK(res1)) {
22445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22446 }
22447 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22448 {
22449 PyThreadState* __tstate = wxPyBeginAllowThreads();
22450 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22451 wxPyEndAllowThreads(__tstate);
22452 if (PyErr_Occurred()) SWIG_fail;
22453 }
22454 resultobj = SWIG_From_int(static_cast< int >(result));
22455 return resultobj;
22456 fail:
22457 return NULL;
22458 }
22459
22460
22461 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22462 PyObject *resultobj = 0;
22463 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22464 int arg2 ;
22465 void *argp1 = 0 ;
22466 int res1 = 0 ;
22467 int val2 ;
22468 int ecode2 = 0 ;
22469 PyObject * obj0 = 0 ;
22470 PyObject * obj1 = 0 ;
22471 char * kwnames[] = {
22472 (char *) "self",(char *) "uniChar", NULL
22473 };
22474
22475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22477 if (!SWIG_IsOK(res1)) {
22478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22479 }
22480 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22481 ecode2 = SWIG_AsVal_int(obj1, &val2);
22482 if (!SWIG_IsOK(ecode2)) {
22483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22484 }
22485 arg2 = static_cast< int >(val2);
22486 {
22487 PyThreadState* __tstate = wxPyBeginAllowThreads();
22488 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22489 wxPyEndAllowThreads(__tstate);
22490 if (PyErr_Occurred()) SWIG_fail;
22491 }
22492 resultobj = SWIG_Py_Void();
22493 return resultobj;
22494 fail:
22495 return NULL;
22496 }
22497
22498
22499 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22500 PyObject *resultobj = 0;
22501 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22502 unsigned int result;
22503 void *argp1 = 0 ;
22504 int res1 = 0 ;
22505 PyObject *swig_obj[1] ;
22506
22507 if (!args) SWIG_fail;
22508 swig_obj[0] = args;
22509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22510 if (!SWIG_IsOK(res1)) {
22511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22512 }
22513 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22514 {
22515 PyThreadState* __tstate = wxPyBeginAllowThreads();
22516 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22517 wxPyEndAllowThreads(__tstate);
22518 if (PyErr_Occurred()) SWIG_fail;
22519 }
22520 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22521 return resultobj;
22522 fail:
22523 return NULL;
22524 }
22525
22526
22527 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22528 PyObject *resultobj = 0;
22529 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22530 unsigned int result;
22531 void *argp1 = 0 ;
22532 int res1 = 0 ;
22533 PyObject *swig_obj[1] ;
22534
22535 if (!args) SWIG_fail;
22536 swig_obj[0] = args;
22537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22538 if (!SWIG_IsOK(res1)) {
22539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22540 }
22541 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22542 {
22543 PyThreadState* __tstate = wxPyBeginAllowThreads();
22544 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22545 wxPyEndAllowThreads(__tstate);
22546 if (PyErr_Occurred()) SWIG_fail;
22547 }
22548 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22549 return resultobj;
22550 fail:
22551 return NULL;
22552 }
22553
22554
22555 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22556 PyObject *resultobj = 0;
22557 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22558 wxPoint result;
22559 void *argp1 = 0 ;
22560 int res1 = 0 ;
22561 PyObject *swig_obj[1] ;
22562
22563 if (!args) SWIG_fail;
22564 swig_obj[0] = args;
22565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22566 if (!SWIG_IsOK(res1)) {
22567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22568 }
22569 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22570 {
22571 PyThreadState* __tstate = wxPyBeginAllowThreads();
22572 result = (arg1)->GetPosition();
22573 wxPyEndAllowThreads(__tstate);
22574 if (PyErr_Occurred()) SWIG_fail;
22575 }
22576 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22577 return resultobj;
22578 fail:
22579 return NULL;
22580 }
22581
22582
22583 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22584 PyObject *resultobj = 0;
22585 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22586 long *arg2 = (long *) 0 ;
22587 long *arg3 = (long *) 0 ;
22588 void *argp1 = 0 ;
22589 int res1 = 0 ;
22590 long temp2 ;
22591 int res2 = SWIG_TMPOBJ ;
22592 long temp3 ;
22593 int res3 = SWIG_TMPOBJ ;
22594 PyObject *swig_obj[1] ;
22595
22596 arg2 = &temp2;
22597 arg3 = &temp3;
22598 if (!args) SWIG_fail;
22599 swig_obj[0] = args;
22600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22601 if (!SWIG_IsOK(res1)) {
22602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22603 }
22604 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22605 {
22606 PyThreadState* __tstate = wxPyBeginAllowThreads();
22607 (arg1)->GetPosition(arg2,arg3);
22608 wxPyEndAllowThreads(__tstate);
22609 if (PyErr_Occurred()) SWIG_fail;
22610 }
22611 resultobj = SWIG_Py_Void();
22612 if (SWIG_IsTmpObj(res2)) {
22613 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22614 } else {
22615 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22616 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22617 }
22618 if (SWIG_IsTmpObj(res3)) {
22619 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22620 } else {
22621 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22622 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22623 }
22624 return resultobj;
22625 fail:
22626 return NULL;
22627 }
22628
22629
22630 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22631 PyObject *resultobj = 0;
22632 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22633 int result;
22634 void *argp1 = 0 ;
22635 int res1 = 0 ;
22636 PyObject *swig_obj[1] ;
22637
22638 if (!args) SWIG_fail;
22639 swig_obj[0] = args;
22640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22641 if (!SWIG_IsOK(res1)) {
22642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22643 }
22644 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22645 {
22646 PyThreadState* __tstate = wxPyBeginAllowThreads();
22647 result = (int)((wxKeyEvent const *)arg1)->GetX();
22648 wxPyEndAllowThreads(__tstate);
22649 if (PyErr_Occurred()) SWIG_fail;
22650 }
22651 resultobj = SWIG_From_int(static_cast< int >(result));
22652 return resultobj;
22653 fail:
22654 return NULL;
22655 }
22656
22657
22658 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22659 PyObject *resultobj = 0;
22660 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22661 int result;
22662 void *argp1 = 0 ;
22663 int res1 = 0 ;
22664 PyObject *swig_obj[1] ;
22665
22666 if (!args) SWIG_fail;
22667 swig_obj[0] = args;
22668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22669 if (!SWIG_IsOK(res1)) {
22670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22671 }
22672 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22673 {
22674 PyThreadState* __tstate = wxPyBeginAllowThreads();
22675 result = (int)((wxKeyEvent const *)arg1)->GetY();
22676 wxPyEndAllowThreads(__tstate);
22677 if (PyErr_Occurred()) SWIG_fail;
22678 }
22679 resultobj = SWIG_From_int(static_cast< int >(result));
22680 return resultobj;
22681 fail:
22682 return NULL;
22683 }
22684
22685
22686 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22687 PyObject *resultobj = 0;
22688 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22689 int arg2 ;
22690 void *argp1 = 0 ;
22691 int res1 = 0 ;
22692 int val2 ;
22693 int ecode2 = 0 ;
22694 PyObject *swig_obj[2] ;
22695
22696 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22698 if (!SWIG_IsOK(res1)) {
22699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22700 }
22701 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22702 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22703 if (!SWIG_IsOK(ecode2)) {
22704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22705 }
22706 arg2 = static_cast< int >(val2);
22707 if (arg1) (arg1)->m_x = arg2;
22708
22709 resultobj = SWIG_Py_Void();
22710 return resultobj;
22711 fail:
22712 return NULL;
22713 }
22714
22715
22716 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22717 PyObject *resultobj = 0;
22718 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22719 int result;
22720 void *argp1 = 0 ;
22721 int res1 = 0 ;
22722 PyObject *swig_obj[1] ;
22723
22724 if (!args) SWIG_fail;
22725 swig_obj[0] = args;
22726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22727 if (!SWIG_IsOK(res1)) {
22728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22729 }
22730 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22731 result = (int) ((arg1)->m_x);
22732 resultobj = SWIG_From_int(static_cast< int >(result));
22733 return resultobj;
22734 fail:
22735 return NULL;
22736 }
22737
22738
22739 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22740 PyObject *resultobj = 0;
22741 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22742 int arg2 ;
22743 void *argp1 = 0 ;
22744 int res1 = 0 ;
22745 int val2 ;
22746 int ecode2 = 0 ;
22747 PyObject *swig_obj[2] ;
22748
22749 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22751 if (!SWIG_IsOK(res1)) {
22752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22753 }
22754 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22755 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22756 if (!SWIG_IsOK(ecode2)) {
22757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22758 }
22759 arg2 = static_cast< int >(val2);
22760 if (arg1) (arg1)->m_y = arg2;
22761
22762 resultobj = SWIG_Py_Void();
22763 return resultobj;
22764 fail:
22765 return NULL;
22766 }
22767
22768
22769 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22770 PyObject *resultobj = 0;
22771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22772 int result;
22773 void *argp1 = 0 ;
22774 int res1 = 0 ;
22775 PyObject *swig_obj[1] ;
22776
22777 if (!args) SWIG_fail;
22778 swig_obj[0] = args;
22779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22780 if (!SWIG_IsOK(res1)) {
22781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22782 }
22783 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22784 result = (int) ((arg1)->m_y);
22785 resultobj = SWIG_From_int(static_cast< int >(result));
22786 return resultobj;
22787 fail:
22788 return NULL;
22789 }
22790
22791
22792 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22793 PyObject *resultobj = 0;
22794 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22795 long arg2 ;
22796 void *argp1 = 0 ;
22797 int res1 = 0 ;
22798 long val2 ;
22799 int ecode2 = 0 ;
22800 PyObject *swig_obj[2] ;
22801
22802 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22804 if (!SWIG_IsOK(res1)) {
22805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22806 }
22807 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22808 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22809 if (!SWIG_IsOK(ecode2)) {
22810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22811 }
22812 arg2 = static_cast< long >(val2);
22813 if (arg1) (arg1)->m_keyCode = arg2;
22814
22815 resultobj = SWIG_Py_Void();
22816 return resultobj;
22817 fail:
22818 return NULL;
22819 }
22820
22821
22822 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22823 PyObject *resultobj = 0;
22824 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22825 long result;
22826 void *argp1 = 0 ;
22827 int res1 = 0 ;
22828 PyObject *swig_obj[1] ;
22829
22830 if (!args) SWIG_fail;
22831 swig_obj[0] = args;
22832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22833 if (!SWIG_IsOK(res1)) {
22834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22835 }
22836 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22837 result = (long) ((arg1)->m_keyCode);
22838 resultobj = SWIG_From_long(static_cast< long >(result));
22839 return resultobj;
22840 fail:
22841 return NULL;
22842 }
22843
22844
22845 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22846 PyObject *resultobj = 0;
22847 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22848 bool arg2 ;
22849 void *argp1 = 0 ;
22850 int res1 = 0 ;
22851 bool val2 ;
22852 int ecode2 = 0 ;
22853 PyObject *swig_obj[2] ;
22854
22855 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22857 if (!SWIG_IsOK(res1)) {
22858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22859 }
22860 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22861 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22862 if (!SWIG_IsOK(ecode2)) {
22863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22864 }
22865 arg2 = static_cast< bool >(val2);
22866 if (arg1) (arg1)->m_controlDown = arg2;
22867
22868 resultobj = SWIG_Py_Void();
22869 return resultobj;
22870 fail:
22871 return NULL;
22872 }
22873
22874
22875 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22876 PyObject *resultobj = 0;
22877 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22878 bool result;
22879 void *argp1 = 0 ;
22880 int res1 = 0 ;
22881 PyObject *swig_obj[1] ;
22882
22883 if (!args) SWIG_fail;
22884 swig_obj[0] = args;
22885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22886 if (!SWIG_IsOK(res1)) {
22887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22888 }
22889 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22890 result = (bool) ((arg1)->m_controlDown);
22891 {
22892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22893 }
22894 return resultobj;
22895 fail:
22896 return NULL;
22897 }
22898
22899
22900 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22901 PyObject *resultobj = 0;
22902 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22903 bool arg2 ;
22904 void *argp1 = 0 ;
22905 int res1 = 0 ;
22906 bool val2 ;
22907 int ecode2 = 0 ;
22908 PyObject *swig_obj[2] ;
22909
22910 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22912 if (!SWIG_IsOK(res1)) {
22913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22914 }
22915 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22916 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22917 if (!SWIG_IsOK(ecode2)) {
22918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22919 }
22920 arg2 = static_cast< bool >(val2);
22921 if (arg1) (arg1)->m_shiftDown = arg2;
22922
22923 resultobj = SWIG_Py_Void();
22924 return resultobj;
22925 fail:
22926 return NULL;
22927 }
22928
22929
22930 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22931 PyObject *resultobj = 0;
22932 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22933 bool result;
22934 void *argp1 = 0 ;
22935 int res1 = 0 ;
22936 PyObject *swig_obj[1] ;
22937
22938 if (!args) SWIG_fail;
22939 swig_obj[0] = args;
22940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22941 if (!SWIG_IsOK(res1)) {
22942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22943 }
22944 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22945 result = (bool) ((arg1)->m_shiftDown);
22946 {
22947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22948 }
22949 return resultobj;
22950 fail:
22951 return NULL;
22952 }
22953
22954
22955 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22956 PyObject *resultobj = 0;
22957 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22958 bool arg2 ;
22959 void *argp1 = 0 ;
22960 int res1 = 0 ;
22961 bool val2 ;
22962 int ecode2 = 0 ;
22963 PyObject *swig_obj[2] ;
22964
22965 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22967 if (!SWIG_IsOK(res1)) {
22968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22969 }
22970 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22971 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22972 if (!SWIG_IsOK(ecode2)) {
22973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22974 }
22975 arg2 = static_cast< bool >(val2);
22976 if (arg1) (arg1)->m_altDown = arg2;
22977
22978 resultobj = SWIG_Py_Void();
22979 return resultobj;
22980 fail:
22981 return NULL;
22982 }
22983
22984
22985 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22986 PyObject *resultobj = 0;
22987 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22988 bool result;
22989 void *argp1 = 0 ;
22990 int res1 = 0 ;
22991 PyObject *swig_obj[1] ;
22992
22993 if (!args) SWIG_fail;
22994 swig_obj[0] = args;
22995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22996 if (!SWIG_IsOK(res1)) {
22997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22998 }
22999 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23000 result = (bool) ((arg1)->m_altDown);
23001 {
23002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23003 }
23004 return resultobj;
23005 fail:
23006 return NULL;
23007 }
23008
23009
23010 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23011 PyObject *resultobj = 0;
23012 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23013 bool arg2 ;
23014 void *argp1 = 0 ;
23015 int res1 = 0 ;
23016 bool val2 ;
23017 int ecode2 = 0 ;
23018 PyObject *swig_obj[2] ;
23019
23020 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
23021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23022 if (!SWIG_IsOK(res1)) {
23023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23024 }
23025 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23026 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23027 if (!SWIG_IsOK(ecode2)) {
23028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
23029 }
23030 arg2 = static_cast< bool >(val2);
23031 if (arg1) (arg1)->m_metaDown = arg2;
23032
23033 resultobj = SWIG_Py_Void();
23034 return resultobj;
23035 fail:
23036 return NULL;
23037 }
23038
23039
23040 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23041 PyObject *resultobj = 0;
23042 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23043 bool result;
23044 void *argp1 = 0 ;
23045 int res1 = 0 ;
23046 PyObject *swig_obj[1] ;
23047
23048 if (!args) SWIG_fail;
23049 swig_obj[0] = args;
23050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23051 if (!SWIG_IsOK(res1)) {
23052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23053 }
23054 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23055 result = (bool) ((arg1)->m_metaDown);
23056 {
23057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23058 }
23059 return resultobj;
23060 fail:
23061 return NULL;
23062 }
23063
23064
23065 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23066 PyObject *resultobj = 0;
23067 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23068 bool arg2 ;
23069 void *argp1 = 0 ;
23070 int res1 = 0 ;
23071 bool val2 ;
23072 int ecode2 = 0 ;
23073 PyObject *swig_obj[2] ;
23074
23075 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
23076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23077 if (!SWIG_IsOK(res1)) {
23078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23079 }
23080 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23081 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
23082 if (!SWIG_IsOK(ecode2)) {
23083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
23084 }
23085 arg2 = static_cast< bool >(val2);
23086 if (arg1) (arg1)->m_scanCode = arg2;
23087
23088 resultobj = SWIG_Py_Void();
23089 return resultobj;
23090 fail:
23091 return NULL;
23092 }
23093
23094
23095 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23096 PyObject *resultobj = 0;
23097 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23098 bool result;
23099 void *argp1 = 0 ;
23100 int res1 = 0 ;
23101 PyObject *swig_obj[1] ;
23102
23103 if (!args) SWIG_fail;
23104 swig_obj[0] = args;
23105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23106 if (!SWIG_IsOK(res1)) {
23107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23108 }
23109 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23110 result = (bool) ((arg1)->m_scanCode);
23111 {
23112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23113 }
23114 return resultobj;
23115 fail:
23116 return NULL;
23117 }
23118
23119
23120 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23121 PyObject *resultobj = 0;
23122 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23123 unsigned int arg2 ;
23124 void *argp1 = 0 ;
23125 int res1 = 0 ;
23126 unsigned int val2 ;
23127 int ecode2 = 0 ;
23128 PyObject *swig_obj[2] ;
23129
23130 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
23131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23132 if (!SWIG_IsOK(res1)) {
23133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23134 }
23135 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23136 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23137 if (!SWIG_IsOK(ecode2)) {
23138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
23139 }
23140 arg2 = static_cast< unsigned int >(val2);
23141 if (arg1) (arg1)->m_rawCode = arg2;
23142
23143 resultobj = SWIG_Py_Void();
23144 return resultobj;
23145 fail:
23146 return NULL;
23147 }
23148
23149
23150 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23151 PyObject *resultobj = 0;
23152 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23153 unsigned int result;
23154 void *argp1 = 0 ;
23155 int res1 = 0 ;
23156 PyObject *swig_obj[1] ;
23157
23158 if (!args) SWIG_fail;
23159 swig_obj[0] = args;
23160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23161 if (!SWIG_IsOK(res1)) {
23162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23163 }
23164 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23165 result = (unsigned int) ((arg1)->m_rawCode);
23166 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23167 return resultobj;
23168 fail:
23169 return NULL;
23170 }
23171
23172
23173 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23174 PyObject *resultobj = 0;
23175 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23176 unsigned int arg2 ;
23177 void *argp1 = 0 ;
23178 int res1 = 0 ;
23179 unsigned int val2 ;
23180 int ecode2 = 0 ;
23181 PyObject *swig_obj[2] ;
23182
23183 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
23184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23185 if (!SWIG_IsOK(res1)) {
23186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23187 }
23188 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23189 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
23190 if (!SWIG_IsOK(ecode2)) {
23191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
23192 }
23193 arg2 = static_cast< unsigned int >(val2);
23194 if (arg1) (arg1)->m_rawFlags = arg2;
23195
23196 resultobj = SWIG_Py_Void();
23197 return resultobj;
23198 fail:
23199 return NULL;
23200 }
23201
23202
23203 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23204 PyObject *resultobj = 0;
23205 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23206 unsigned int result;
23207 void *argp1 = 0 ;
23208 int res1 = 0 ;
23209 PyObject *swig_obj[1] ;
23210
23211 if (!args) SWIG_fail;
23212 swig_obj[0] = args;
23213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23214 if (!SWIG_IsOK(res1)) {
23215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23216 }
23217 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23218 result = (unsigned int) ((arg1)->m_rawFlags);
23219 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23220 return resultobj;
23221 fail:
23222 return NULL;
23223 }
23224
23225
23226 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23227 PyObject *obj;
23228 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23229 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23230 return SWIG_Py_Void();
23231 }
23232
23233 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23234 return SWIG_Python_InitShadowInstance(args);
23235 }
23236
23237 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23238 PyObject *resultobj = 0;
23239 wxSize const &arg1_defvalue = wxDefaultSize ;
23240 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23241 int arg2 = (int) 0 ;
23242 wxSizeEvent *result = 0 ;
23243 wxSize temp1 ;
23244 int val2 ;
23245 int ecode2 = 0 ;
23246 PyObject * obj0 = 0 ;
23247 PyObject * obj1 = 0 ;
23248 char * kwnames[] = {
23249 (char *) "sz",(char *) "winid", NULL
23250 };
23251
23252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23253 if (obj0) {
23254 {
23255 arg1 = &temp1;
23256 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23257 }
23258 }
23259 if (obj1) {
23260 ecode2 = SWIG_AsVal_int(obj1, &val2);
23261 if (!SWIG_IsOK(ecode2)) {
23262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23263 }
23264 arg2 = static_cast< int >(val2);
23265 }
23266 {
23267 PyThreadState* __tstate = wxPyBeginAllowThreads();
23268 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23269 wxPyEndAllowThreads(__tstate);
23270 if (PyErr_Occurred()) SWIG_fail;
23271 }
23272 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23273 return resultobj;
23274 fail:
23275 return NULL;
23276 }
23277
23278
23279 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23280 PyObject *resultobj = 0;
23281 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23282 wxSize result;
23283 void *argp1 = 0 ;
23284 int res1 = 0 ;
23285 PyObject *swig_obj[1] ;
23286
23287 if (!args) SWIG_fail;
23288 swig_obj[0] = args;
23289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23290 if (!SWIG_IsOK(res1)) {
23291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23292 }
23293 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23294 {
23295 PyThreadState* __tstate = wxPyBeginAllowThreads();
23296 result = ((wxSizeEvent const *)arg1)->GetSize();
23297 wxPyEndAllowThreads(__tstate);
23298 if (PyErr_Occurred()) SWIG_fail;
23299 }
23300 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23301 return resultobj;
23302 fail:
23303 return NULL;
23304 }
23305
23306
23307 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23308 PyObject *resultobj = 0;
23309 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23310 wxRect result;
23311 void *argp1 = 0 ;
23312 int res1 = 0 ;
23313 PyObject *swig_obj[1] ;
23314
23315 if (!args) SWIG_fail;
23316 swig_obj[0] = args;
23317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23318 if (!SWIG_IsOK(res1)) {
23319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23320 }
23321 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23322 {
23323 PyThreadState* __tstate = wxPyBeginAllowThreads();
23324 result = ((wxSizeEvent const *)arg1)->GetRect();
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23336 PyObject *resultobj = 0;
23337 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23338 wxRect arg2 ;
23339 void *argp1 = 0 ;
23340 int res1 = 0 ;
23341 void *argp2 ;
23342 int res2 = 0 ;
23343 PyObject * obj0 = 0 ;
23344 PyObject * obj1 = 0 ;
23345 char * kwnames[] = {
23346 (char *) "self",(char *) "rect", NULL
23347 };
23348
23349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23351 if (!SWIG_IsOK(res1)) {
23352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23353 }
23354 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23355 {
23356 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23357 if (!SWIG_IsOK(res2)) {
23358 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23359 }
23360 if (!argp2) {
23361 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23362 } else {
23363 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23364 arg2 = *temp;
23365 if (SWIG_IsNewObj(res2)) delete temp;
23366 }
23367 }
23368 {
23369 PyThreadState* __tstate = wxPyBeginAllowThreads();
23370 (arg1)->SetRect(arg2);
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 resultobj = SWIG_Py_Void();
23375 return resultobj;
23376 fail:
23377 return NULL;
23378 }
23379
23380
23381 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23382 PyObject *resultobj = 0;
23383 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23384 wxSize arg2 ;
23385 void *argp1 = 0 ;
23386 int res1 = 0 ;
23387 void *argp2 ;
23388 int res2 = 0 ;
23389 PyObject * obj0 = 0 ;
23390 PyObject * obj1 = 0 ;
23391 char * kwnames[] = {
23392 (char *) "self",(char *) "size", NULL
23393 };
23394
23395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23397 if (!SWIG_IsOK(res1)) {
23398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23399 }
23400 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23401 {
23402 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23403 if (!SWIG_IsOK(res2)) {
23404 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23405 }
23406 if (!argp2) {
23407 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23408 } else {
23409 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23410 arg2 = *temp;
23411 if (SWIG_IsNewObj(res2)) delete temp;
23412 }
23413 }
23414 {
23415 PyThreadState* __tstate = wxPyBeginAllowThreads();
23416 wxSizeEvent_SetSize(arg1,arg2);
23417 wxPyEndAllowThreads(__tstate);
23418 if (PyErr_Occurred()) SWIG_fail;
23419 }
23420 resultobj = SWIG_Py_Void();
23421 return resultobj;
23422 fail:
23423 return NULL;
23424 }
23425
23426
23427 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23428 PyObject *resultobj = 0;
23429 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23430 wxSize *arg2 = (wxSize *) 0 ;
23431 void *argp1 = 0 ;
23432 int res1 = 0 ;
23433 void *argp2 = 0 ;
23434 int res2 = 0 ;
23435 PyObject *swig_obj[2] ;
23436
23437 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23439 if (!SWIG_IsOK(res1)) {
23440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23441 }
23442 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23443 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23444 if (!SWIG_IsOK(res2)) {
23445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23446 }
23447 arg2 = reinterpret_cast< wxSize * >(argp2);
23448 if (arg1) (arg1)->m_size = *arg2;
23449
23450 resultobj = SWIG_Py_Void();
23451 return resultobj;
23452 fail:
23453 return NULL;
23454 }
23455
23456
23457 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23458 PyObject *resultobj = 0;
23459 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23460 wxSize *result = 0 ;
23461 void *argp1 = 0 ;
23462 int res1 = 0 ;
23463 PyObject *swig_obj[1] ;
23464
23465 if (!args) SWIG_fail;
23466 swig_obj[0] = args;
23467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23468 if (!SWIG_IsOK(res1)) {
23469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23470 }
23471 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23472 result = (wxSize *)& ((arg1)->m_size);
23473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23481 PyObject *resultobj = 0;
23482 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23483 wxRect *arg2 = (wxRect *) 0 ;
23484 void *argp1 = 0 ;
23485 int res1 = 0 ;
23486 void *argp2 = 0 ;
23487 int res2 = 0 ;
23488 PyObject *swig_obj[2] ;
23489
23490 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23492 if (!SWIG_IsOK(res1)) {
23493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23494 }
23495 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23496 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23497 if (!SWIG_IsOK(res2)) {
23498 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23499 }
23500 arg2 = reinterpret_cast< wxRect * >(argp2);
23501 if (arg1) (arg1)->m_rect = *arg2;
23502
23503 resultobj = SWIG_Py_Void();
23504 return resultobj;
23505 fail:
23506 return NULL;
23507 }
23508
23509
23510 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23511 PyObject *resultobj = 0;
23512 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23513 wxRect *result = 0 ;
23514 void *argp1 = 0 ;
23515 int res1 = 0 ;
23516 PyObject *swig_obj[1] ;
23517
23518 if (!args) SWIG_fail;
23519 swig_obj[0] = args;
23520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23521 if (!SWIG_IsOK(res1)) {
23522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23523 }
23524 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23525 result = (wxRect *)& ((arg1)->m_rect);
23526 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23527 return resultobj;
23528 fail:
23529 return NULL;
23530 }
23531
23532
23533 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23534 PyObject *obj;
23535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23536 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23537 return SWIG_Py_Void();
23538 }
23539
23540 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23541 return SWIG_Python_InitShadowInstance(args);
23542 }
23543
23544 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23545 PyObject *resultobj = 0;
23546 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23547 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23548 int arg2 = (int) 0 ;
23549 wxMoveEvent *result = 0 ;
23550 wxPoint temp1 ;
23551 int val2 ;
23552 int ecode2 = 0 ;
23553 PyObject * obj0 = 0 ;
23554 PyObject * obj1 = 0 ;
23555 char * kwnames[] = {
23556 (char *) "pos",(char *) "winid", NULL
23557 };
23558
23559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23560 if (obj0) {
23561 {
23562 arg1 = &temp1;
23563 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23564 }
23565 }
23566 if (obj1) {
23567 ecode2 = SWIG_AsVal_int(obj1, &val2);
23568 if (!SWIG_IsOK(ecode2)) {
23569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23570 }
23571 arg2 = static_cast< int >(val2);
23572 }
23573 {
23574 PyThreadState* __tstate = wxPyBeginAllowThreads();
23575 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23576 wxPyEndAllowThreads(__tstate);
23577 if (PyErr_Occurred()) SWIG_fail;
23578 }
23579 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23580 return resultobj;
23581 fail:
23582 return NULL;
23583 }
23584
23585
23586 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23587 PyObject *resultobj = 0;
23588 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23589 wxPoint result;
23590 void *argp1 = 0 ;
23591 int res1 = 0 ;
23592 PyObject *swig_obj[1] ;
23593
23594 if (!args) SWIG_fail;
23595 swig_obj[0] = args;
23596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23597 if (!SWIG_IsOK(res1)) {
23598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23599 }
23600 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23601 {
23602 PyThreadState* __tstate = wxPyBeginAllowThreads();
23603 result = ((wxMoveEvent const *)arg1)->GetPosition();
23604 wxPyEndAllowThreads(__tstate);
23605 if (PyErr_Occurred()) SWIG_fail;
23606 }
23607 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23608 return resultobj;
23609 fail:
23610 return NULL;
23611 }
23612
23613
23614 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23615 PyObject *resultobj = 0;
23616 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23617 wxRect result;
23618 void *argp1 = 0 ;
23619 int res1 = 0 ;
23620 PyObject *swig_obj[1] ;
23621
23622 if (!args) SWIG_fail;
23623 swig_obj[0] = args;
23624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23625 if (!SWIG_IsOK(res1)) {
23626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23627 }
23628 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 result = ((wxMoveEvent const *)arg1)->GetRect();
23632 wxPyEndAllowThreads(__tstate);
23633 if (PyErr_Occurred()) SWIG_fail;
23634 }
23635 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23636 return resultobj;
23637 fail:
23638 return NULL;
23639 }
23640
23641
23642 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23643 PyObject *resultobj = 0;
23644 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23645 wxRect *arg2 = 0 ;
23646 void *argp1 = 0 ;
23647 int res1 = 0 ;
23648 wxRect temp2 ;
23649 PyObject * obj0 = 0 ;
23650 PyObject * obj1 = 0 ;
23651 char * kwnames[] = {
23652 (char *) "self",(char *) "rect", NULL
23653 };
23654
23655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23657 if (!SWIG_IsOK(res1)) {
23658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23659 }
23660 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23661 {
23662 arg2 = &temp2;
23663 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23664 }
23665 {
23666 PyThreadState* __tstate = wxPyBeginAllowThreads();
23667 (arg1)->SetRect((wxRect const &)*arg2);
23668 wxPyEndAllowThreads(__tstate);
23669 if (PyErr_Occurred()) SWIG_fail;
23670 }
23671 resultobj = SWIG_Py_Void();
23672 return resultobj;
23673 fail:
23674 return NULL;
23675 }
23676
23677
23678 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23679 PyObject *resultobj = 0;
23680 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23681 wxPoint *arg2 = 0 ;
23682 void *argp1 = 0 ;
23683 int res1 = 0 ;
23684 wxPoint temp2 ;
23685 PyObject * obj0 = 0 ;
23686 PyObject * obj1 = 0 ;
23687 char * kwnames[] = {
23688 (char *) "self",(char *) "pos", NULL
23689 };
23690
23691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23693 if (!SWIG_IsOK(res1)) {
23694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23695 }
23696 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23697 {
23698 arg2 = &temp2;
23699 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23700 }
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 (arg1)->SetPosition((wxPoint const &)*arg2);
23704 wxPyEndAllowThreads(__tstate);
23705 if (PyErr_Occurred()) SWIG_fail;
23706 }
23707 resultobj = SWIG_Py_Void();
23708 return resultobj;
23709 fail:
23710 return NULL;
23711 }
23712
23713
23714 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23715 PyObject *obj;
23716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23717 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23718 return SWIG_Py_Void();
23719 }
23720
23721 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23722 return SWIG_Python_InitShadowInstance(args);
23723 }
23724
23725 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23726 PyObject *resultobj = 0;
23727 int arg1 = (int) 0 ;
23728 wxPaintEvent *result = 0 ;
23729 int val1 ;
23730 int ecode1 = 0 ;
23731 PyObject * obj0 = 0 ;
23732 char * kwnames[] = {
23733 (char *) "Id", NULL
23734 };
23735
23736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23737 if (obj0) {
23738 ecode1 = SWIG_AsVal_int(obj0, &val1);
23739 if (!SWIG_IsOK(ecode1)) {
23740 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23741 }
23742 arg1 = static_cast< int >(val1);
23743 }
23744 {
23745 PyThreadState* __tstate = wxPyBeginAllowThreads();
23746 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23747 wxPyEndAllowThreads(__tstate);
23748 if (PyErr_Occurred()) SWIG_fail;
23749 }
23750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23751 return resultobj;
23752 fail:
23753 return NULL;
23754 }
23755
23756
23757 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23758 PyObject *obj;
23759 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23760 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23761 return SWIG_Py_Void();
23762 }
23763
23764 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23765 return SWIG_Python_InitShadowInstance(args);
23766 }
23767
23768 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23769 PyObject *resultobj = 0;
23770 int arg1 = (int) 0 ;
23771 wxNcPaintEvent *result = 0 ;
23772 int val1 ;
23773 int ecode1 = 0 ;
23774 PyObject * obj0 = 0 ;
23775 char * kwnames[] = {
23776 (char *) "winid", NULL
23777 };
23778
23779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23780 if (obj0) {
23781 ecode1 = SWIG_AsVal_int(obj0, &val1);
23782 if (!SWIG_IsOK(ecode1)) {
23783 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23784 }
23785 arg1 = static_cast< int >(val1);
23786 }
23787 {
23788 PyThreadState* __tstate = wxPyBeginAllowThreads();
23789 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23790 wxPyEndAllowThreads(__tstate);
23791 if (PyErr_Occurred()) SWIG_fail;
23792 }
23793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23794 return resultobj;
23795 fail:
23796 return NULL;
23797 }
23798
23799
23800 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23801 PyObject *obj;
23802 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23803 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23804 return SWIG_Py_Void();
23805 }
23806
23807 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23808 return SWIG_Python_InitShadowInstance(args);
23809 }
23810
23811 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23812 PyObject *resultobj = 0;
23813 int arg1 = (int) 0 ;
23814 wxDC *arg2 = (wxDC *) NULL ;
23815 wxEraseEvent *result = 0 ;
23816 int val1 ;
23817 int ecode1 = 0 ;
23818 void *argp2 = 0 ;
23819 int res2 = 0 ;
23820 PyObject * obj0 = 0 ;
23821 PyObject * obj1 = 0 ;
23822 char * kwnames[] = {
23823 (char *) "Id",(char *) "dc", NULL
23824 };
23825
23826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23827 if (obj0) {
23828 ecode1 = SWIG_AsVal_int(obj0, &val1);
23829 if (!SWIG_IsOK(ecode1)) {
23830 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23831 }
23832 arg1 = static_cast< int >(val1);
23833 }
23834 if (obj1) {
23835 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23836 if (!SWIG_IsOK(res2)) {
23837 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23838 }
23839 arg2 = reinterpret_cast< wxDC * >(argp2);
23840 }
23841 {
23842 PyThreadState* __tstate = wxPyBeginAllowThreads();
23843 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23844 wxPyEndAllowThreads(__tstate);
23845 if (PyErr_Occurred()) SWIG_fail;
23846 }
23847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23848 return resultobj;
23849 fail:
23850 return NULL;
23851 }
23852
23853
23854 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23855 PyObject *resultobj = 0;
23856 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23857 wxDC *result = 0 ;
23858 void *argp1 = 0 ;
23859 int res1 = 0 ;
23860 PyObject *swig_obj[1] ;
23861
23862 if (!args) SWIG_fail;
23863 swig_obj[0] = args;
23864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23865 if (!SWIG_IsOK(res1)) {
23866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23867 }
23868 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23869 {
23870 PyThreadState* __tstate = wxPyBeginAllowThreads();
23871 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 {
23876 resultobj = wxPyMake_wxObject(result, (bool)0);
23877 }
23878 return resultobj;
23879 fail:
23880 return NULL;
23881 }
23882
23883
23884 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23885 PyObject *obj;
23886 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23887 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23888 return SWIG_Py_Void();
23889 }
23890
23891 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23892 return SWIG_Python_InitShadowInstance(args);
23893 }
23894
23895 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23896 PyObject *resultobj = 0;
23897 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23898 int arg2 = (int) 0 ;
23899 wxFocusEvent *result = 0 ;
23900 int val1 ;
23901 int ecode1 = 0 ;
23902 int val2 ;
23903 int ecode2 = 0 ;
23904 PyObject * obj0 = 0 ;
23905 PyObject * obj1 = 0 ;
23906 char * kwnames[] = {
23907 (char *) "type",(char *) "winid", NULL
23908 };
23909
23910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23911 if (obj0) {
23912 ecode1 = SWIG_AsVal_int(obj0, &val1);
23913 if (!SWIG_IsOK(ecode1)) {
23914 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23915 }
23916 arg1 = static_cast< wxEventType >(val1);
23917 }
23918 if (obj1) {
23919 ecode2 = SWIG_AsVal_int(obj1, &val2);
23920 if (!SWIG_IsOK(ecode2)) {
23921 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23922 }
23923 arg2 = static_cast< int >(val2);
23924 }
23925 {
23926 PyThreadState* __tstate = wxPyBeginAllowThreads();
23927 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23928 wxPyEndAllowThreads(__tstate);
23929 if (PyErr_Occurred()) SWIG_fail;
23930 }
23931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23932 return resultobj;
23933 fail:
23934 return NULL;
23935 }
23936
23937
23938 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23939 PyObject *resultobj = 0;
23940 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23941 wxWindow *result = 0 ;
23942 void *argp1 = 0 ;
23943 int res1 = 0 ;
23944 PyObject *swig_obj[1] ;
23945
23946 if (!args) SWIG_fail;
23947 swig_obj[0] = args;
23948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23949 if (!SWIG_IsOK(res1)) {
23950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23951 }
23952 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23953 {
23954 PyThreadState* __tstate = wxPyBeginAllowThreads();
23955 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23956 wxPyEndAllowThreads(__tstate);
23957 if (PyErr_Occurred()) SWIG_fail;
23958 }
23959 {
23960 resultobj = wxPyMake_wxObject(result, (bool)0);
23961 }
23962 return resultobj;
23963 fail:
23964 return NULL;
23965 }
23966
23967
23968 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23969 PyObject *resultobj = 0;
23970 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23971 wxWindow *arg2 = (wxWindow *) 0 ;
23972 void *argp1 = 0 ;
23973 int res1 = 0 ;
23974 void *argp2 = 0 ;
23975 int res2 = 0 ;
23976 PyObject * obj0 = 0 ;
23977 PyObject * obj1 = 0 ;
23978 char * kwnames[] = {
23979 (char *) "self",(char *) "win", NULL
23980 };
23981
23982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23984 if (!SWIG_IsOK(res1)) {
23985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23986 }
23987 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23988 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23989 if (!SWIG_IsOK(res2)) {
23990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23991 }
23992 arg2 = reinterpret_cast< wxWindow * >(argp2);
23993 {
23994 PyThreadState* __tstate = wxPyBeginAllowThreads();
23995 (arg1)->SetWindow(arg2);
23996 wxPyEndAllowThreads(__tstate);
23997 if (PyErr_Occurred()) SWIG_fail;
23998 }
23999 resultobj = SWIG_Py_Void();
24000 return resultobj;
24001 fail:
24002 return NULL;
24003 }
24004
24005
24006 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24007 PyObject *obj;
24008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24009 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
24010 return SWIG_Py_Void();
24011 }
24012
24013 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24014 return SWIG_Python_InitShadowInstance(args);
24015 }
24016
24017 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24018 PyObject *resultobj = 0;
24019 wxWindow *arg1 = (wxWindow *) NULL ;
24020 wxChildFocusEvent *result = 0 ;
24021 void *argp1 = 0 ;
24022 int res1 = 0 ;
24023 PyObject * obj0 = 0 ;
24024 char * kwnames[] = {
24025 (char *) "win", NULL
24026 };
24027
24028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
24029 if (obj0) {
24030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
24031 if (!SWIG_IsOK(res1)) {
24032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
24033 }
24034 arg1 = reinterpret_cast< wxWindow * >(argp1);
24035 }
24036 {
24037 PyThreadState* __tstate = wxPyBeginAllowThreads();
24038 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
24039 wxPyEndAllowThreads(__tstate);
24040 if (PyErr_Occurred()) SWIG_fail;
24041 }
24042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
24043 return resultobj;
24044 fail:
24045 return NULL;
24046 }
24047
24048
24049 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24050 PyObject *resultobj = 0;
24051 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
24052 wxWindow *result = 0 ;
24053 void *argp1 = 0 ;
24054 int res1 = 0 ;
24055 PyObject *swig_obj[1] ;
24056
24057 if (!args) SWIG_fail;
24058 swig_obj[0] = args;
24059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
24060 if (!SWIG_IsOK(res1)) {
24061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
24062 }
24063 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
24067 wxPyEndAllowThreads(__tstate);
24068 if (PyErr_Occurred()) SWIG_fail;
24069 }
24070 {
24071 resultobj = wxPyMake_wxObject(result, (bool)0);
24072 }
24073 return resultobj;
24074 fail:
24075 return NULL;
24076 }
24077
24078
24079 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24080 PyObject *obj;
24081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24082 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
24083 return SWIG_Py_Void();
24084 }
24085
24086 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24087 return SWIG_Python_InitShadowInstance(args);
24088 }
24089
24090 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24091 PyObject *resultobj = 0;
24092 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24093 bool arg2 = (bool) true ;
24094 int arg3 = (int) 0 ;
24095 wxActivateEvent *result = 0 ;
24096 int val1 ;
24097 int ecode1 = 0 ;
24098 bool val2 ;
24099 int ecode2 = 0 ;
24100 int val3 ;
24101 int ecode3 = 0 ;
24102 PyObject * obj0 = 0 ;
24103 PyObject * obj1 = 0 ;
24104 PyObject * obj2 = 0 ;
24105 char * kwnames[] = {
24106 (char *) "type",(char *) "active",(char *) "Id", NULL
24107 };
24108
24109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24110 if (obj0) {
24111 ecode1 = SWIG_AsVal_int(obj0, &val1);
24112 if (!SWIG_IsOK(ecode1)) {
24113 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24114 }
24115 arg1 = static_cast< wxEventType >(val1);
24116 }
24117 if (obj1) {
24118 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24119 if (!SWIG_IsOK(ecode2)) {
24120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
24121 }
24122 arg2 = static_cast< bool >(val2);
24123 }
24124 if (obj2) {
24125 ecode3 = SWIG_AsVal_int(obj2, &val3);
24126 if (!SWIG_IsOK(ecode3)) {
24127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
24128 }
24129 arg3 = static_cast< int >(val3);
24130 }
24131 {
24132 PyThreadState* __tstate = wxPyBeginAllowThreads();
24133 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
24134 wxPyEndAllowThreads(__tstate);
24135 if (PyErr_Occurred()) SWIG_fail;
24136 }
24137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
24138 return resultobj;
24139 fail:
24140 return NULL;
24141 }
24142
24143
24144 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24145 PyObject *resultobj = 0;
24146 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
24147 bool result;
24148 void *argp1 = 0 ;
24149 int res1 = 0 ;
24150 PyObject *swig_obj[1] ;
24151
24152 if (!args) SWIG_fail;
24153 swig_obj[0] = args;
24154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
24155 if (!SWIG_IsOK(res1)) {
24156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
24157 }
24158 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
24159 {
24160 PyThreadState* __tstate = wxPyBeginAllowThreads();
24161 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
24162 wxPyEndAllowThreads(__tstate);
24163 if (PyErr_Occurred()) SWIG_fail;
24164 }
24165 {
24166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24167 }
24168 return resultobj;
24169 fail:
24170 return NULL;
24171 }
24172
24173
24174 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24175 PyObject *obj;
24176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24177 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
24178 return SWIG_Py_Void();
24179 }
24180
24181 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24182 return SWIG_Python_InitShadowInstance(args);
24183 }
24184
24185 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24186 PyObject *resultobj = 0;
24187 int arg1 = (int) 0 ;
24188 wxInitDialogEvent *result = 0 ;
24189 int val1 ;
24190 int ecode1 = 0 ;
24191 PyObject * obj0 = 0 ;
24192 char * kwnames[] = {
24193 (char *) "Id", NULL
24194 };
24195
24196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
24197 if (obj0) {
24198 ecode1 = SWIG_AsVal_int(obj0, &val1);
24199 if (!SWIG_IsOK(ecode1)) {
24200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24201 }
24202 arg1 = static_cast< int >(val1);
24203 }
24204 {
24205 PyThreadState* __tstate = wxPyBeginAllowThreads();
24206 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24207 wxPyEndAllowThreads(__tstate);
24208 if (PyErr_Occurred()) SWIG_fail;
24209 }
24210 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24211 return resultobj;
24212 fail:
24213 return NULL;
24214 }
24215
24216
24217 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24218 PyObject *obj;
24219 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24220 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24221 return SWIG_Py_Void();
24222 }
24223
24224 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24225 return SWIG_Python_InitShadowInstance(args);
24226 }
24227
24228 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24229 PyObject *resultobj = 0;
24230 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24231 int arg2 = (int) 0 ;
24232 wxMenu *arg3 = (wxMenu *) NULL ;
24233 wxMenuEvent *result = 0 ;
24234 int val1 ;
24235 int ecode1 = 0 ;
24236 int val2 ;
24237 int ecode2 = 0 ;
24238 void *argp3 = 0 ;
24239 int res3 = 0 ;
24240 PyObject * obj0 = 0 ;
24241 PyObject * obj1 = 0 ;
24242 PyObject * obj2 = 0 ;
24243 char * kwnames[] = {
24244 (char *) "type",(char *) "winid",(char *) "menu", NULL
24245 };
24246
24247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24248 if (obj0) {
24249 ecode1 = SWIG_AsVal_int(obj0, &val1);
24250 if (!SWIG_IsOK(ecode1)) {
24251 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24252 }
24253 arg1 = static_cast< wxEventType >(val1);
24254 }
24255 if (obj1) {
24256 ecode2 = SWIG_AsVal_int(obj1, &val2);
24257 if (!SWIG_IsOK(ecode2)) {
24258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24259 }
24260 arg2 = static_cast< int >(val2);
24261 }
24262 if (obj2) {
24263 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24264 if (!SWIG_IsOK(res3)) {
24265 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24266 }
24267 arg3 = reinterpret_cast< wxMenu * >(argp3);
24268 }
24269 {
24270 PyThreadState* __tstate = wxPyBeginAllowThreads();
24271 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24272 wxPyEndAllowThreads(__tstate);
24273 if (PyErr_Occurred()) SWIG_fail;
24274 }
24275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24276 return resultobj;
24277 fail:
24278 return NULL;
24279 }
24280
24281
24282 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24283 PyObject *resultobj = 0;
24284 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24285 int result;
24286 void *argp1 = 0 ;
24287 int res1 = 0 ;
24288 PyObject *swig_obj[1] ;
24289
24290 if (!args) SWIG_fail;
24291 swig_obj[0] = args;
24292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24293 if (!SWIG_IsOK(res1)) {
24294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24295 }
24296 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24297 {
24298 PyThreadState* __tstate = wxPyBeginAllowThreads();
24299 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24300 wxPyEndAllowThreads(__tstate);
24301 if (PyErr_Occurred()) SWIG_fail;
24302 }
24303 resultobj = SWIG_From_int(static_cast< int >(result));
24304 return resultobj;
24305 fail:
24306 return NULL;
24307 }
24308
24309
24310 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24311 PyObject *resultobj = 0;
24312 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24313 bool result;
24314 void *argp1 = 0 ;
24315 int res1 = 0 ;
24316 PyObject *swig_obj[1] ;
24317
24318 if (!args) SWIG_fail;
24319 swig_obj[0] = args;
24320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24321 if (!SWIG_IsOK(res1)) {
24322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24323 }
24324 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24325 {
24326 PyThreadState* __tstate = wxPyBeginAllowThreads();
24327 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24328 wxPyEndAllowThreads(__tstate);
24329 if (PyErr_Occurred()) SWIG_fail;
24330 }
24331 {
24332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24333 }
24334 return resultobj;
24335 fail:
24336 return NULL;
24337 }
24338
24339
24340 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24341 PyObject *resultobj = 0;
24342 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24343 wxMenu *result = 0 ;
24344 void *argp1 = 0 ;
24345 int res1 = 0 ;
24346 PyObject *swig_obj[1] ;
24347
24348 if (!args) SWIG_fail;
24349 swig_obj[0] = args;
24350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24351 if (!SWIG_IsOK(res1)) {
24352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24353 }
24354 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24355 {
24356 PyThreadState* __tstate = wxPyBeginAllowThreads();
24357 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24358 wxPyEndAllowThreads(__tstate);
24359 if (PyErr_Occurred()) SWIG_fail;
24360 }
24361 {
24362 resultobj = wxPyMake_wxObject(result, (bool)0);
24363 }
24364 return resultobj;
24365 fail:
24366 return NULL;
24367 }
24368
24369
24370 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24371 PyObject *obj;
24372 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24373 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24374 return SWIG_Py_Void();
24375 }
24376
24377 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24378 return SWIG_Python_InitShadowInstance(args);
24379 }
24380
24381 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24382 PyObject *resultobj = 0;
24383 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24384 int arg2 = (int) 0 ;
24385 wxCloseEvent *result = 0 ;
24386 int val1 ;
24387 int ecode1 = 0 ;
24388 int val2 ;
24389 int ecode2 = 0 ;
24390 PyObject * obj0 = 0 ;
24391 PyObject * obj1 = 0 ;
24392 char * kwnames[] = {
24393 (char *) "type",(char *) "winid", NULL
24394 };
24395
24396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24397 if (obj0) {
24398 ecode1 = SWIG_AsVal_int(obj0, &val1);
24399 if (!SWIG_IsOK(ecode1)) {
24400 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24401 }
24402 arg1 = static_cast< wxEventType >(val1);
24403 }
24404 if (obj1) {
24405 ecode2 = SWIG_AsVal_int(obj1, &val2);
24406 if (!SWIG_IsOK(ecode2)) {
24407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24408 }
24409 arg2 = static_cast< int >(val2);
24410 }
24411 {
24412 PyThreadState* __tstate = wxPyBeginAllowThreads();
24413 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24414 wxPyEndAllowThreads(__tstate);
24415 if (PyErr_Occurred()) SWIG_fail;
24416 }
24417 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24418 return resultobj;
24419 fail:
24420 return NULL;
24421 }
24422
24423
24424 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24425 PyObject *resultobj = 0;
24426 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24427 bool arg2 ;
24428 void *argp1 = 0 ;
24429 int res1 = 0 ;
24430 bool val2 ;
24431 int ecode2 = 0 ;
24432 PyObject * obj0 = 0 ;
24433 PyObject * obj1 = 0 ;
24434 char * kwnames[] = {
24435 (char *) "self",(char *) "logOff", NULL
24436 };
24437
24438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24440 if (!SWIG_IsOK(res1)) {
24441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24442 }
24443 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24444 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24445 if (!SWIG_IsOK(ecode2)) {
24446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24447 }
24448 arg2 = static_cast< bool >(val2);
24449 {
24450 PyThreadState* __tstate = wxPyBeginAllowThreads();
24451 (arg1)->SetLoggingOff(arg2);
24452 wxPyEndAllowThreads(__tstate);
24453 if (PyErr_Occurred()) SWIG_fail;
24454 }
24455 resultobj = SWIG_Py_Void();
24456 return resultobj;
24457 fail:
24458 return NULL;
24459 }
24460
24461
24462 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24463 PyObject *resultobj = 0;
24464 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24465 bool result;
24466 void *argp1 = 0 ;
24467 int res1 = 0 ;
24468 PyObject *swig_obj[1] ;
24469
24470 if (!args) SWIG_fail;
24471 swig_obj[0] = args;
24472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24473 if (!SWIG_IsOK(res1)) {
24474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24475 }
24476 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24477 {
24478 PyThreadState* __tstate = wxPyBeginAllowThreads();
24479 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24480 wxPyEndAllowThreads(__tstate);
24481 if (PyErr_Occurred()) SWIG_fail;
24482 }
24483 {
24484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24485 }
24486 return resultobj;
24487 fail:
24488 return NULL;
24489 }
24490
24491
24492 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24493 PyObject *resultobj = 0;
24494 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24495 bool arg2 = (bool) true ;
24496 void *argp1 = 0 ;
24497 int res1 = 0 ;
24498 bool val2 ;
24499 int ecode2 = 0 ;
24500 PyObject * obj0 = 0 ;
24501 PyObject * obj1 = 0 ;
24502 char * kwnames[] = {
24503 (char *) "self",(char *) "veto", NULL
24504 };
24505
24506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24508 if (!SWIG_IsOK(res1)) {
24509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24510 }
24511 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24512 if (obj1) {
24513 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24514 if (!SWIG_IsOK(ecode2)) {
24515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24516 }
24517 arg2 = static_cast< bool >(val2);
24518 }
24519 {
24520 PyThreadState* __tstate = wxPyBeginAllowThreads();
24521 (arg1)->Veto(arg2);
24522 wxPyEndAllowThreads(__tstate);
24523 if (PyErr_Occurred()) SWIG_fail;
24524 }
24525 resultobj = SWIG_Py_Void();
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24533 PyObject *resultobj = 0;
24534 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24535 bool result;
24536 void *argp1 = 0 ;
24537 int res1 = 0 ;
24538 PyObject *swig_obj[1] ;
24539
24540 if (!args) SWIG_fail;
24541 swig_obj[0] = args;
24542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24543 if (!SWIG_IsOK(res1)) {
24544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24545 }
24546 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24547 {
24548 PyThreadState* __tstate = wxPyBeginAllowThreads();
24549 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 {
24554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24555 }
24556 return resultobj;
24557 fail:
24558 return NULL;
24559 }
24560
24561
24562 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24563 PyObject *resultobj = 0;
24564 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24565 bool arg2 ;
24566 void *argp1 = 0 ;
24567 int res1 = 0 ;
24568 bool val2 ;
24569 int ecode2 = 0 ;
24570 PyObject * obj0 = 0 ;
24571 PyObject * obj1 = 0 ;
24572 char * kwnames[] = {
24573 (char *) "self",(char *) "canVeto", NULL
24574 };
24575
24576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24578 if (!SWIG_IsOK(res1)) {
24579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24580 }
24581 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24582 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24583 if (!SWIG_IsOK(ecode2)) {
24584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24585 }
24586 arg2 = static_cast< bool >(val2);
24587 {
24588 PyThreadState* __tstate = wxPyBeginAllowThreads();
24589 (arg1)->SetCanVeto(arg2);
24590 wxPyEndAllowThreads(__tstate);
24591 if (PyErr_Occurred()) SWIG_fail;
24592 }
24593 resultobj = SWIG_Py_Void();
24594 return resultobj;
24595 fail:
24596 return NULL;
24597 }
24598
24599
24600 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24601 PyObject *resultobj = 0;
24602 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24603 bool result;
24604 void *argp1 = 0 ;
24605 int res1 = 0 ;
24606 PyObject *swig_obj[1] ;
24607
24608 if (!args) SWIG_fail;
24609 swig_obj[0] = args;
24610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24611 if (!SWIG_IsOK(res1)) {
24612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24613 }
24614 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24615 {
24616 PyThreadState* __tstate = wxPyBeginAllowThreads();
24617 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24618 wxPyEndAllowThreads(__tstate);
24619 if (PyErr_Occurred()) SWIG_fail;
24620 }
24621 {
24622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24623 }
24624 return resultobj;
24625 fail:
24626 return NULL;
24627 }
24628
24629
24630 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24631 PyObject *obj;
24632 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24633 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24634 return SWIG_Py_Void();
24635 }
24636
24637 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24638 return SWIG_Python_InitShadowInstance(args);
24639 }
24640
24641 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24642 PyObject *resultobj = 0;
24643 int arg1 = (int) 0 ;
24644 bool arg2 = (bool) false ;
24645 wxShowEvent *result = 0 ;
24646 int val1 ;
24647 int ecode1 = 0 ;
24648 bool val2 ;
24649 int ecode2 = 0 ;
24650 PyObject * obj0 = 0 ;
24651 PyObject * obj1 = 0 ;
24652 char * kwnames[] = {
24653 (char *) "winid",(char *) "show", NULL
24654 };
24655
24656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24657 if (obj0) {
24658 ecode1 = SWIG_AsVal_int(obj0, &val1);
24659 if (!SWIG_IsOK(ecode1)) {
24660 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24661 }
24662 arg1 = static_cast< int >(val1);
24663 }
24664 if (obj1) {
24665 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24666 if (!SWIG_IsOK(ecode2)) {
24667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24668 }
24669 arg2 = static_cast< bool >(val2);
24670 }
24671 {
24672 PyThreadState* __tstate = wxPyBeginAllowThreads();
24673 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24674 wxPyEndAllowThreads(__tstate);
24675 if (PyErr_Occurred()) SWIG_fail;
24676 }
24677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24678 return resultobj;
24679 fail:
24680 return NULL;
24681 }
24682
24683
24684 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24685 PyObject *resultobj = 0;
24686 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24687 bool arg2 ;
24688 void *argp1 = 0 ;
24689 int res1 = 0 ;
24690 bool val2 ;
24691 int ecode2 = 0 ;
24692 PyObject * obj0 = 0 ;
24693 PyObject * obj1 = 0 ;
24694 char * kwnames[] = {
24695 (char *) "self",(char *) "show", NULL
24696 };
24697
24698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24700 if (!SWIG_IsOK(res1)) {
24701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24702 }
24703 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24704 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24705 if (!SWIG_IsOK(ecode2)) {
24706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24707 }
24708 arg2 = static_cast< bool >(val2);
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 (arg1)->SetShow(arg2);
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 resultobj = SWIG_Py_Void();
24716 return resultobj;
24717 fail:
24718 return NULL;
24719 }
24720
24721
24722 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24723 PyObject *resultobj = 0;
24724 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24725 bool result;
24726 void *argp1 = 0 ;
24727 int res1 = 0 ;
24728 PyObject *swig_obj[1] ;
24729
24730 if (!args) SWIG_fail;
24731 swig_obj[0] = args;
24732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24733 if (!SWIG_IsOK(res1)) {
24734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24735 }
24736 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24737 {
24738 PyThreadState* __tstate = wxPyBeginAllowThreads();
24739 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24740 wxPyEndAllowThreads(__tstate);
24741 if (PyErr_Occurred()) SWIG_fail;
24742 }
24743 {
24744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24745 }
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24753 PyObject *obj;
24754 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24755 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24756 return SWIG_Py_Void();
24757 }
24758
24759 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24760 return SWIG_Python_InitShadowInstance(args);
24761 }
24762
24763 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24764 PyObject *resultobj = 0;
24765 int arg1 = (int) 0 ;
24766 bool arg2 = (bool) true ;
24767 wxIconizeEvent *result = 0 ;
24768 int val1 ;
24769 int ecode1 = 0 ;
24770 bool val2 ;
24771 int ecode2 = 0 ;
24772 PyObject * obj0 = 0 ;
24773 PyObject * obj1 = 0 ;
24774 char * kwnames[] = {
24775 (char *) "id",(char *) "iconized", NULL
24776 };
24777
24778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24779 if (obj0) {
24780 ecode1 = SWIG_AsVal_int(obj0, &val1);
24781 if (!SWIG_IsOK(ecode1)) {
24782 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24783 }
24784 arg1 = static_cast< int >(val1);
24785 }
24786 if (obj1) {
24787 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24788 if (!SWIG_IsOK(ecode2)) {
24789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24790 }
24791 arg2 = static_cast< bool >(val2);
24792 }
24793 {
24794 PyThreadState* __tstate = wxPyBeginAllowThreads();
24795 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24796 wxPyEndAllowThreads(__tstate);
24797 if (PyErr_Occurred()) SWIG_fail;
24798 }
24799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24800 return resultobj;
24801 fail:
24802 return NULL;
24803 }
24804
24805
24806 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24807 PyObject *resultobj = 0;
24808 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24809 bool result;
24810 void *argp1 = 0 ;
24811 int res1 = 0 ;
24812 PyObject *swig_obj[1] ;
24813
24814 if (!args) SWIG_fail;
24815 swig_obj[0] = args;
24816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24817 if (!SWIG_IsOK(res1)) {
24818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24819 }
24820 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24821 {
24822 PyThreadState* __tstate = wxPyBeginAllowThreads();
24823 result = (bool)(arg1)->Iconized();
24824 wxPyEndAllowThreads(__tstate);
24825 if (PyErr_Occurred()) SWIG_fail;
24826 }
24827 {
24828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24829 }
24830 return resultobj;
24831 fail:
24832 return NULL;
24833 }
24834
24835
24836 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24837 PyObject *obj;
24838 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24839 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24840 return SWIG_Py_Void();
24841 }
24842
24843 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24844 return SWIG_Python_InitShadowInstance(args);
24845 }
24846
24847 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24848 PyObject *resultobj = 0;
24849 int arg1 = (int) 0 ;
24850 wxMaximizeEvent *result = 0 ;
24851 int val1 ;
24852 int ecode1 = 0 ;
24853 PyObject * obj0 = 0 ;
24854 char * kwnames[] = {
24855 (char *) "id", NULL
24856 };
24857
24858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24859 if (obj0) {
24860 ecode1 = SWIG_AsVal_int(obj0, &val1);
24861 if (!SWIG_IsOK(ecode1)) {
24862 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24863 }
24864 arg1 = static_cast< int >(val1);
24865 }
24866 {
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24869 wxPyEndAllowThreads(__tstate);
24870 if (PyErr_Occurred()) SWIG_fail;
24871 }
24872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24880 PyObject *obj;
24881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24882 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24883 return SWIG_Py_Void();
24884 }
24885
24886 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24887 return SWIG_Python_InitShadowInstance(args);
24888 }
24889
24890 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24891 PyObject *resultobj = 0;
24892 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24893 wxPoint result;
24894 void *argp1 = 0 ;
24895 int res1 = 0 ;
24896 PyObject *swig_obj[1] ;
24897
24898 if (!args) SWIG_fail;
24899 swig_obj[0] = args;
24900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24901 if (!SWIG_IsOK(res1)) {
24902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24903 }
24904 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24905 {
24906 PyThreadState* __tstate = wxPyBeginAllowThreads();
24907 result = (arg1)->GetPosition();
24908 wxPyEndAllowThreads(__tstate);
24909 if (PyErr_Occurred()) SWIG_fail;
24910 }
24911 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24912 return resultobj;
24913 fail:
24914 return NULL;
24915 }
24916
24917
24918 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24919 PyObject *resultobj = 0;
24920 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24921 int result;
24922 void *argp1 = 0 ;
24923 int res1 = 0 ;
24924 PyObject *swig_obj[1] ;
24925
24926 if (!args) SWIG_fail;
24927 swig_obj[0] = args;
24928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24929 if (!SWIG_IsOK(res1)) {
24930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24931 }
24932 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24933 {
24934 PyThreadState* __tstate = wxPyBeginAllowThreads();
24935 result = (int)(arg1)->GetNumberOfFiles();
24936 wxPyEndAllowThreads(__tstate);
24937 if (PyErr_Occurred()) SWIG_fail;
24938 }
24939 resultobj = SWIG_From_int(static_cast< int >(result));
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24947 PyObject *resultobj = 0;
24948 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24949 PyObject *result = 0 ;
24950 void *argp1 = 0 ;
24951 int res1 = 0 ;
24952 PyObject *swig_obj[1] ;
24953
24954 if (!args) SWIG_fail;
24955 swig_obj[0] = args;
24956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24957 if (!SWIG_IsOK(res1)) {
24958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24959 }
24960 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24961 {
24962 PyThreadState* __tstate = wxPyBeginAllowThreads();
24963 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24964 wxPyEndAllowThreads(__tstate);
24965 if (PyErr_Occurred()) SWIG_fail;
24966 }
24967 resultobj = result;
24968 return resultobj;
24969 fail:
24970 return NULL;
24971 }
24972
24973
24974 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24975 PyObject *obj;
24976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24977 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24978 return SWIG_Py_Void();
24979 }
24980
24981 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24982 PyObject *resultobj = 0;
24983 int arg1 = (int) 0 ;
24984 wxUpdateUIEvent *result = 0 ;
24985 int val1 ;
24986 int ecode1 = 0 ;
24987 PyObject * obj0 = 0 ;
24988 char * kwnames[] = {
24989 (char *) "commandId", NULL
24990 };
24991
24992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24993 if (obj0) {
24994 ecode1 = SWIG_AsVal_int(obj0, &val1);
24995 if (!SWIG_IsOK(ecode1)) {
24996 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24997 }
24998 arg1 = static_cast< int >(val1);
24999 }
25000 {
25001 PyThreadState* __tstate = wxPyBeginAllowThreads();
25002 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
25003 wxPyEndAllowThreads(__tstate);
25004 if (PyErr_Occurred()) SWIG_fail;
25005 }
25006 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
25007 return resultobj;
25008 fail:
25009 return NULL;
25010 }
25011
25012
25013 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25014 PyObject *resultobj = 0;
25015 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25016 bool result;
25017 void *argp1 = 0 ;
25018 int res1 = 0 ;
25019 PyObject *swig_obj[1] ;
25020
25021 if (!args) SWIG_fail;
25022 swig_obj[0] = args;
25023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25024 if (!SWIG_IsOK(res1)) {
25025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25026 }
25027 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25028 {
25029 PyThreadState* __tstate = wxPyBeginAllowThreads();
25030 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
25031 wxPyEndAllowThreads(__tstate);
25032 if (PyErr_Occurred()) SWIG_fail;
25033 }
25034 {
25035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25036 }
25037 return resultobj;
25038 fail:
25039 return NULL;
25040 }
25041
25042
25043 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25044 PyObject *resultobj = 0;
25045 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25046 bool result;
25047 void *argp1 = 0 ;
25048 int res1 = 0 ;
25049 PyObject *swig_obj[1] ;
25050
25051 if (!args) SWIG_fail;
25052 swig_obj[0] = args;
25053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25054 if (!SWIG_IsOK(res1)) {
25055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25056 }
25057 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25058 {
25059 PyThreadState* __tstate = wxPyBeginAllowThreads();
25060 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
25061 wxPyEndAllowThreads(__tstate);
25062 if (PyErr_Occurred()) SWIG_fail;
25063 }
25064 {
25065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25066 }
25067 return resultobj;
25068 fail:
25069 return NULL;
25070 }
25071
25072
25073 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25074 PyObject *resultobj = 0;
25075 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25076 bool result;
25077 void *argp1 = 0 ;
25078 int res1 = 0 ;
25079 PyObject *swig_obj[1] ;
25080
25081 if (!args) SWIG_fail;
25082 swig_obj[0] = args;
25083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25084 if (!SWIG_IsOK(res1)) {
25085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25086 }
25087 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25088 {
25089 PyThreadState* __tstate = wxPyBeginAllowThreads();
25090 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 {
25095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25096 }
25097 return resultobj;
25098 fail:
25099 return NULL;
25100 }
25101
25102
25103 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25104 PyObject *resultobj = 0;
25105 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25106 wxString result;
25107 void *argp1 = 0 ;
25108 int res1 = 0 ;
25109 PyObject *swig_obj[1] ;
25110
25111 if (!args) SWIG_fail;
25112 swig_obj[0] = args;
25113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25114 if (!SWIG_IsOK(res1)) {
25115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25116 }
25117 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25118 {
25119 PyThreadState* __tstate = wxPyBeginAllowThreads();
25120 result = ((wxUpdateUIEvent const *)arg1)->GetText();
25121 wxPyEndAllowThreads(__tstate);
25122 if (PyErr_Occurred()) SWIG_fail;
25123 }
25124 {
25125 #if wxUSE_UNICODE
25126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25127 #else
25128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25129 #endif
25130 }
25131 return resultobj;
25132 fail:
25133 return NULL;
25134 }
25135
25136
25137 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25138 PyObject *resultobj = 0;
25139 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25140 bool result;
25141 void *argp1 = 0 ;
25142 int res1 = 0 ;
25143 PyObject *swig_obj[1] ;
25144
25145 if (!args) SWIG_fail;
25146 swig_obj[0] = args;
25147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25148 if (!SWIG_IsOK(res1)) {
25149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25150 }
25151 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25152 {
25153 PyThreadState* __tstate = wxPyBeginAllowThreads();
25154 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
25155 wxPyEndAllowThreads(__tstate);
25156 if (PyErr_Occurred()) SWIG_fail;
25157 }
25158 {
25159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25160 }
25161 return resultobj;
25162 fail:
25163 return NULL;
25164 }
25165
25166
25167 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25168 PyObject *resultobj = 0;
25169 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25170 bool result;
25171 void *argp1 = 0 ;
25172 int res1 = 0 ;
25173 PyObject *swig_obj[1] ;
25174
25175 if (!args) SWIG_fail;
25176 swig_obj[0] = args;
25177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25178 if (!SWIG_IsOK(res1)) {
25179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25180 }
25181 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25182 {
25183 PyThreadState* __tstate = wxPyBeginAllowThreads();
25184 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
25185 wxPyEndAllowThreads(__tstate);
25186 if (PyErr_Occurred()) SWIG_fail;
25187 }
25188 {
25189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25190 }
25191 return resultobj;
25192 fail:
25193 return NULL;
25194 }
25195
25196
25197 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25198 PyObject *resultobj = 0;
25199 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25200 bool result;
25201 void *argp1 = 0 ;
25202 int res1 = 0 ;
25203 PyObject *swig_obj[1] ;
25204
25205 if (!args) SWIG_fail;
25206 swig_obj[0] = args;
25207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25208 if (!SWIG_IsOK(res1)) {
25209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25210 }
25211 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25212 {
25213 PyThreadState* __tstate = wxPyBeginAllowThreads();
25214 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25215 wxPyEndAllowThreads(__tstate);
25216 if (PyErr_Occurred()) SWIG_fail;
25217 }
25218 {
25219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25220 }
25221 return resultobj;
25222 fail:
25223 return NULL;
25224 }
25225
25226
25227 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25228 PyObject *resultobj = 0;
25229 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25230 bool result;
25231 void *argp1 = 0 ;
25232 int res1 = 0 ;
25233 PyObject *swig_obj[1] ;
25234
25235 if (!args) SWIG_fail;
25236 swig_obj[0] = args;
25237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25238 if (!SWIG_IsOK(res1)) {
25239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25240 }
25241 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25242 {
25243 PyThreadState* __tstate = wxPyBeginAllowThreads();
25244 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25245 wxPyEndAllowThreads(__tstate);
25246 if (PyErr_Occurred()) SWIG_fail;
25247 }
25248 {
25249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25250 }
25251 return resultobj;
25252 fail:
25253 return NULL;
25254 }
25255
25256
25257 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25258 PyObject *resultobj = 0;
25259 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25260 bool arg2 ;
25261 void *argp1 = 0 ;
25262 int res1 = 0 ;
25263 bool val2 ;
25264 int ecode2 = 0 ;
25265 PyObject * obj0 = 0 ;
25266 PyObject * obj1 = 0 ;
25267 char * kwnames[] = {
25268 (char *) "self",(char *) "check", NULL
25269 };
25270
25271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25273 if (!SWIG_IsOK(res1)) {
25274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25275 }
25276 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25277 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25278 if (!SWIG_IsOK(ecode2)) {
25279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25280 }
25281 arg2 = static_cast< bool >(val2);
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 (arg1)->Check(arg2);
25285 wxPyEndAllowThreads(__tstate);
25286 if (PyErr_Occurred()) SWIG_fail;
25287 }
25288 resultobj = SWIG_Py_Void();
25289 return resultobj;
25290 fail:
25291 return NULL;
25292 }
25293
25294
25295 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25296 PyObject *resultobj = 0;
25297 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25298 bool arg2 ;
25299 void *argp1 = 0 ;
25300 int res1 = 0 ;
25301 bool val2 ;
25302 int ecode2 = 0 ;
25303 PyObject * obj0 = 0 ;
25304 PyObject * obj1 = 0 ;
25305 char * kwnames[] = {
25306 (char *) "self",(char *) "enable", NULL
25307 };
25308
25309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25311 if (!SWIG_IsOK(res1)) {
25312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25313 }
25314 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25315 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25316 if (!SWIG_IsOK(ecode2)) {
25317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25318 }
25319 arg2 = static_cast< bool >(val2);
25320 {
25321 PyThreadState* __tstate = wxPyBeginAllowThreads();
25322 (arg1)->Enable(arg2);
25323 wxPyEndAllowThreads(__tstate);
25324 if (PyErr_Occurred()) SWIG_fail;
25325 }
25326 resultobj = SWIG_Py_Void();
25327 return resultobj;
25328 fail:
25329 return NULL;
25330 }
25331
25332
25333 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25334 PyObject *resultobj = 0;
25335 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25336 bool arg2 ;
25337 void *argp1 = 0 ;
25338 int res1 = 0 ;
25339 bool val2 ;
25340 int ecode2 = 0 ;
25341 PyObject * obj0 = 0 ;
25342 PyObject * obj1 = 0 ;
25343 char * kwnames[] = {
25344 (char *) "self",(char *) "show", NULL
25345 };
25346
25347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25349 if (!SWIG_IsOK(res1)) {
25350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25351 }
25352 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25354 if (!SWIG_IsOK(ecode2)) {
25355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25356 }
25357 arg2 = static_cast< bool >(val2);
25358 {
25359 PyThreadState* __tstate = wxPyBeginAllowThreads();
25360 (arg1)->Show(arg2);
25361 wxPyEndAllowThreads(__tstate);
25362 if (PyErr_Occurred()) SWIG_fail;
25363 }
25364 resultobj = SWIG_Py_Void();
25365 return resultobj;
25366 fail:
25367 return NULL;
25368 }
25369
25370
25371 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25372 PyObject *resultobj = 0;
25373 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25374 wxString *arg2 = 0 ;
25375 void *argp1 = 0 ;
25376 int res1 = 0 ;
25377 bool temp2 = false ;
25378 PyObject * obj0 = 0 ;
25379 PyObject * obj1 = 0 ;
25380 char * kwnames[] = {
25381 (char *) "self",(char *) "text", NULL
25382 };
25383
25384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25386 if (!SWIG_IsOK(res1)) {
25387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25388 }
25389 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25390 {
25391 arg2 = wxString_in_helper(obj1);
25392 if (arg2 == NULL) SWIG_fail;
25393 temp2 = true;
25394 }
25395 {
25396 PyThreadState* __tstate = wxPyBeginAllowThreads();
25397 (arg1)->SetText((wxString const &)*arg2);
25398 wxPyEndAllowThreads(__tstate);
25399 if (PyErr_Occurred()) SWIG_fail;
25400 }
25401 resultobj = SWIG_Py_Void();
25402 {
25403 if (temp2)
25404 delete arg2;
25405 }
25406 return resultobj;
25407 fail:
25408 {
25409 if (temp2)
25410 delete arg2;
25411 }
25412 return NULL;
25413 }
25414
25415
25416 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25417 PyObject *resultobj = 0;
25418 long arg1 ;
25419 long val1 ;
25420 int ecode1 = 0 ;
25421 PyObject * obj0 = 0 ;
25422 char * kwnames[] = {
25423 (char *) "updateInterval", NULL
25424 };
25425
25426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25427 ecode1 = SWIG_AsVal_long(obj0, &val1);
25428 if (!SWIG_IsOK(ecode1)) {
25429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25430 }
25431 arg1 = static_cast< long >(val1);
25432 {
25433 PyThreadState* __tstate = wxPyBeginAllowThreads();
25434 wxUpdateUIEvent::SetUpdateInterval(arg1);
25435 wxPyEndAllowThreads(__tstate);
25436 if (PyErr_Occurred()) SWIG_fail;
25437 }
25438 resultobj = SWIG_Py_Void();
25439 return resultobj;
25440 fail:
25441 return NULL;
25442 }
25443
25444
25445 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25446 PyObject *resultobj = 0;
25447 long result;
25448
25449 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25450 {
25451 PyThreadState* __tstate = wxPyBeginAllowThreads();
25452 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25453 wxPyEndAllowThreads(__tstate);
25454 if (PyErr_Occurred()) SWIG_fail;
25455 }
25456 resultobj = SWIG_From_long(static_cast< long >(result));
25457 return resultobj;
25458 fail:
25459 return NULL;
25460 }
25461
25462
25463 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25464 PyObject *resultobj = 0;
25465 wxWindow *arg1 = (wxWindow *) 0 ;
25466 bool result;
25467 void *argp1 = 0 ;
25468 int res1 = 0 ;
25469 PyObject * obj0 = 0 ;
25470 char * kwnames[] = {
25471 (char *) "win", NULL
25472 };
25473
25474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25476 if (!SWIG_IsOK(res1)) {
25477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25478 }
25479 arg1 = reinterpret_cast< wxWindow * >(argp1);
25480 {
25481 PyThreadState* __tstate = wxPyBeginAllowThreads();
25482 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25483 wxPyEndAllowThreads(__tstate);
25484 if (PyErr_Occurred()) SWIG_fail;
25485 }
25486 {
25487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25488 }
25489 return resultobj;
25490 fail:
25491 return NULL;
25492 }
25493
25494
25495 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25496 PyObject *resultobj = 0;
25497
25498 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25499 {
25500 PyThreadState* __tstate = wxPyBeginAllowThreads();
25501 wxUpdateUIEvent::ResetUpdateTime();
25502 wxPyEndAllowThreads(__tstate);
25503 if (PyErr_Occurred()) SWIG_fail;
25504 }
25505 resultobj = SWIG_Py_Void();
25506 return resultobj;
25507 fail:
25508 return NULL;
25509 }
25510
25511
25512 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25513 PyObject *resultobj = 0;
25514 wxUpdateUIMode arg1 ;
25515 int val1 ;
25516 int ecode1 = 0 ;
25517 PyObject * obj0 = 0 ;
25518 char * kwnames[] = {
25519 (char *) "mode", NULL
25520 };
25521
25522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25523 ecode1 = SWIG_AsVal_int(obj0, &val1);
25524 if (!SWIG_IsOK(ecode1)) {
25525 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25526 }
25527 arg1 = static_cast< wxUpdateUIMode >(val1);
25528 {
25529 PyThreadState* __tstate = wxPyBeginAllowThreads();
25530 wxUpdateUIEvent::SetMode(arg1);
25531 wxPyEndAllowThreads(__tstate);
25532 if (PyErr_Occurred()) SWIG_fail;
25533 }
25534 resultobj = SWIG_Py_Void();
25535 return resultobj;
25536 fail:
25537 return NULL;
25538 }
25539
25540
25541 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25542 PyObject *resultobj = 0;
25543 wxUpdateUIMode result;
25544
25545 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25546 {
25547 PyThreadState* __tstate = wxPyBeginAllowThreads();
25548 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25549 wxPyEndAllowThreads(__tstate);
25550 if (PyErr_Occurred()) SWIG_fail;
25551 }
25552 resultobj = SWIG_From_int(static_cast< int >(result));
25553 return resultobj;
25554 fail:
25555 return NULL;
25556 }
25557
25558
25559 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25560 PyObject *obj;
25561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25562 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25563 return SWIG_Py_Void();
25564 }
25565
25566 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25567 return SWIG_Python_InitShadowInstance(args);
25568 }
25569
25570 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25571 PyObject *resultobj = 0;
25572 wxSysColourChangedEvent *result = 0 ;
25573
25574 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25575 {
25576 PyThreadState* __tstate = wxPyBeginAllowThreads();
25577 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25578 wxPyEndAllowThreads(__tstate);
25579 if (PyErr_Occurred()) SWIG_fail;
25580 }
25581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25582 return resultobj;
25583 fail:
25584 return NULL;
25585 }
25586
25587
25588 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25589 PyObject *obj;
25590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25591 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25592 return SWIG_Py_Void();
25593 }
25594
25595 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25596 return SWIG_Python_InitShadowInstance(args);
25597 }
25598
25599 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25600 PyObject *resultobj = 0;
25601 int arg1 = (int) 0 ;
25602 wxWindow *arg2 = (wxWindow *) NULL ;
25603 wxMouseCaptureChangedEvent *result = 0 ;
25604 int val1 ;
25605 int ecode1 = 0 ;
25606 void *argp2 = 0 ;
25607 int res2 = 0 ;
25608 PyObject * obj0 = 0 ;
25609 PyObject * obj1 = 0 ;
25610 char * kwnames[] = {
25611 (char *) "winid",(char *) "gainedCapture", NULL
25612 };
25613
25614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25615 if (obj0) {
25616 ecode1 = SWIG_AsVal_int(obj0, &val1);
25617 if (!SWIG_IsOK(ecode1)) {
25618 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25619 }
25620 arg1 = static_cast< int >(val1);
25621 }
25622 if (obj1) {
25623 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25624 if (!SWIG_IsOK(res2)) {
25625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25626 }
25627 arg2 = reinterpret_cast< wxWindow * >(argp2);
25628 }
25629 {
25630 PyThreadState* __tstate = wxPyBeginAllowThreads();
25631 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25632 wxPyEndAllowThreads(__tstate);
25633 if (PyErr_Occurred()) SWIG_fail;
25634 }
25635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25636 return resultobj;
25637 fail:
25638 return NULL;
25639 }
25640
25641
25642 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25643 PyObject *resultobj = 0;
25644 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25645 wxWindow *result = 0 ;
25646 void *argp1 = 0 ;
25647 int res1 = 0 ;
25648 PyObject *swig_obj[1] ;
25649
25650 if (!args) SWIG_fail;
25651 swig_obj[0] = args;
25652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25653 if (!SWIG_IsOK(res1)) {
25654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25655 }
25656 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25657 {
25658 PyThreadState* __tstate = wxPyBeginAllowThreads();
25659 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25660 wxPyEndAllowThreads(__tstate);
25661 if (PyErr_Occurred()) SWIG_fail;
25662 }
25663 {
25664 resultobj = wxPyMake_wxObject(result, (bool)0);
25665 }
25666 return resultobj;
25667 fail:
25668 return NULL;
25669 }
25670
25671
25672 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25673 PyObject *obj;
25674 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25675 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25676 return SWIG_Py_Void();
25677 }
25678
25679 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25680 return SWIG_Python_InitShadowInstance(args);
25681 }
25682
25683 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25684 PyObject *resultobj = 0;
25685 int arg1 = (int) 0 ;
25686 wxMouseCaptureLostEvent *result = 0 ;
25687 int val1 ;
25688 int ecode1 = 0 ;
25689 PyObject * obj0 = 0 ;
25690 char * kwnames[] = {
25691 (char *) "winid", NULL
25692 };
25693
25694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25695 if (obj0) {
25696 ecode1 = SWIG_AsVal_int(obj0, &val1);
25697 if (!SWIG_IsOK(ecode1)) {
25698 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25699 }
25700 arg1 = static_cast< int >(val1);
25701 }
25702 {
25703 PyThreadState* __tstate = wxPyBeginAllowThreads();
25704 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25705 wxPyEndAllowThreads(__tstate);
25706 if (PyErr_Occurred()) SWIG_fail;
25707 }
25708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25709 return resultobj;
25710 fail:
25711 return NULL;
25712 }
25713
25714
25715 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25716 PyObject *obj;
25717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25718 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25719 return SWIG_Py_Void();
25720 }
25721
25722 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25723 return SWIG_Python_InitShadowInstance(args);
25724 }
25725
25726 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25727 PyObject *resultobj = 0;
25728 wxDisplayChangedEvent *result = 0 ;
25729
25730 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25731 {
25732 PyThreadState* __tstate = wxPyBeginAllowThreads();
25733 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25734 wxPyEndAllowThreads(__tstate);
25735 if (PyErr_Occurred()) SWIG_fail;
25736 }
25737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25738 return resultobj;
25739 fail:
25740 return NULL;
25741 }
25742
25743
25744 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25745 PyObject *obj;
25746 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25747 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25748 return SWIG_Py_Void();
25749 }
25750
25751 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25752 return SWIG_Python_InitShadowInstance(args);
25753 }
25754
25755 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25756 PyObject *resultobj = 0;
25757 int arg1 = (int) 0 ;
25758 wxPaletteChangedEvent *result = 0 ;
25759 int val1 ;
25760 int ecode1 = 0 ;
25761 PyObject * obj0 = 0 ;
25762 char * kwnames[] = {
25763 (char *) "id", NULL
25764 };
25765
25766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25767 if (obj0) {
25768 ecode1 = SWIG_AsVal_int(obj0, &val1);
25769 if (!SWIG_IsOK(ecode1)) {
25770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25771 }
25772 arg1 = static_cast< int >(val1);
25773 }
25774 {
25775 PyThreadState* __tstate = wxPyBeginAllowThreads();
25776 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25777 wxPyEndAllowThreads(__tstate);
25778 if (PyErr_Occurred()) SWIG_fail;
25779 }
25780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25781 return resultobj;
25782 fail:
25783 return NULL;
25784 }
25785
25786
25787 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25788 PyObject *resultobj = 0;
25789 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25790 wxWindow *arg2 = (wxWindow *) 0 ;
25791 void *argp1 = 0 ;
25792 int res1 = 0 ;
25793 void *argp2 = 0 ;
25794 int res2 = 0 ;
25795 PyObject * obj0 = 0 ;
25796 PyObject * obj1 = 0 ;
25797 char * kwnames[] = {
25798 (char *) "self",(char *) "win", NULL
25799 };
25800
25801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25803 if (!SWIG_IsOK(res1)) {
25804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25805 }
25806 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25807 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25808 if (!SWIG_IsOK(res2)) {
25809 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25810 }
25811 arg2 = reinterpret_cast< wxWindow * >(argp2);
25812 {
25813 PyThreadState* __tstate = wxPyBeginAllowThreads();
25814 (arg1)->SetChangedWindow(arg2);
25815 wxPyEndAllowThreads(__tstate);
25816 if (PyErr_Occurred()) SWIG_fail;
25817 }
25818 resultobj = SWIG_Py_Void();
25819 return resultobj;
25820 fail:
25821 return NULL;
25822 }
25823
25824
25825 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25826 PyObject *resultobj = 0;
25827 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25828 wxWindow *result = 0 ;
25829 void *argp1 = 0 ;
25830 int res1 = 0 ;
25831 PyObject *swig_obj[1] ;
25832
25833 if (!args) SWIG_fail;
25834 swig_obj[0] = args;
25835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25836 if (!SWIG_IsOK(res1)) {
25837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25838 }
25839 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25840 {
25841 PyThreadState* __tstate = wxPyBeginAllowThreads();
25842 result = (wxWindow *)(arg1)->GetChangedWindow();
25843 wxPyEndAllowThreads(__tstate);
25844 if (PyErr_Occurred()) SWIG_fail;
25845 }
25846 {
25847 resultobj = wxPyMake_wxObject(result, (bool)0);
25848 }
25849 return resultobj;
25850 fail:
25851 return NULL;
25852 }
25853
25854
25855 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25856 PyObject *obj;
25857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25858 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25859 return SWIG_Py_Void();
25860 }
25861
25862 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25863 return SWIG_Python_InitShadowInstance(args);
25864 }
25865
25866 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25867 PyObject *resultobj = 0;
25868 int arg1 = (int) 0 ;
25869 wxQueryNewPaletteEvent *result = 0 ;
25870 int val1 ;
25871 int ecode1 = 0 ;
25872 PyObject * obj0 = 0 ;
25873 char * kwnames[] = {
25874 (char *) "winid", NULL
25875 };
25876
25877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25878 if (obj0) {
25879 ecode1 = SWIG_AsVal_int(obj0, &val1);
25880 if (!SWIG_IsOK(ecode1)) {
25881 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25882 }
25883 arg1 = static_cast< int >(val1);
25884 }
25885 {
25886 PyThreadState* __tstate = wxPyBeginAllowThreads();
25887 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25888 wxPyEndAllowThreads(__tstate);
25889 if (PyErr_Occurred()) SWIG_fail;
25890 }
25891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25892 return resultobj;
25893 fail:
25894 return NULL;
25895 }
25896
25897
25898 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25899 PyObject *resultobj = 0;
25900 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25901 bool arg2 ;
25902 void *argp1 = 0 ;
25903 int res1 = 0 ;
25904 bool val2 ;
25905 int ecode2 = 0 ;
25906 PyObject * obj0 = 0 ;
25907 PyObject * obj1 = 0 ;
25908 char * kwnames[] = {
25909 (char *) "self",(char *) "realized", NULL
25910 };
25911
25912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25914 if (!SWIG_IsOK(res1)) {
25915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25916 }
25917 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25918 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25919 if (!SWIG_IsOK(ecode2)) {
25920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25921 }
25922 arg2 = static_cast< bool >(val2);
25923 {
25924 PyThreadState* __tstate = wxPyBeginAllowThreads();
25925 (arg1)->SetPaletteRealized(arg2);
25926 wxPyEndAllowThreads(__tstate);
25927 if (PyErr_Occurred()) SWIG_fail;
25928 }
25929 resultobj = SWIG_Py_Void();
25930 return resultobj;
25931 fail:
25932 return NULL;
25933 }
25934
25935
25936 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25937 PyObject *resultobj = 0;
25938 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25939 bool result;
25940 void *argp1 = 0 ;
25941 int res1 = 0 ;
25942 PyObject *swig_obj[1] ;
25943
25944 if (!args) SWIG_fail;
25945 swig_obj[0] = args;
25946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25947 if (!SWIG_IsOK(res1)) {
25948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25949 }
25950 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25951 {
25952 PyThreadState* __tstate = wxPyBeginAllowThreads();
25953 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25954 wxPyEndAllowThreads(__tstate);
25955 if (PyErr_Occurred()) SWIG_fail;
25956 }
25957 {
25958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25959 }
25960 return resultobj;
25961 fail:
25962 return NULL;
25963 }
25964
25965
25966 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25967 PyObject *obj;
25968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25969 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25970 return SWIG_Py_Void();
25971 }
25972
25973 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25974 return SWIG_Python_InitShadowInstance(args);
25975 }
25976
25977 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25978 PyObject *resultobj = 0;
25979 wxNavigationKeyEvent *result = 0 ;
25980
25981 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25982 {
25983 PyThreadState* __tstate = wxPyBeginAllowThreads();
25984 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25985 wxPyEndAllowThreads(__tstate);
25986 if (PyErr_Occurred()) SWIG_fail;
25987 }
25988 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25989 return resultobj;
25990 fail:
25991 return NULL;
25992 }
25993
25994
25995 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25996 PyObject *resultobj = 0;
25997 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25998 bool result;
25999 void *argp1 = 0 ;
26000 int res1 = 0 ;
26001 PyObject *swig_obj[1] ;
26002
26003 if (!args) SWIG_fail;
26004 swig_obj[0] = args;
26005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26006 if (!SWIG_IsOK(res1)) {
26007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26008 }
26009 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26010 {
26011 PyThreadState* __tstate = wxPyBeginAllowThreads();
26012 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
26013 wxPyEndAllowThreads(__tstate);
26014 if (PyErr_Occurred()) SWIG_fail;
26015 }
26016 {
26017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26018 }
26019 return resultobj;
26020 fail:
26021 return NULL;
26022 }
26023
26024
26025 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26026 PyObject *resultobj = 0;
26027 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26028 bool arg2 ;
26029 void *argp1 = 0 ;
26030 int res1 = 0 ;
26031 bool val2 ;
26032 int ecode2 = 0 ;
26033 PyObject * obj0 = 0 ;
26034 PyObject * obj1 = 0 ;
26035 char * kwnames[] = {
26036 (char *) "self",(char *) "forward", NULL
26037 };
26038
26039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
26040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26041 if (!SWIG_IsOK(res1)) {
26042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26043 }
26044 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26045 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26046 if (!SWIG_IsOK(ecode2)) {
26047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
26048 }
26049 arg2 = static_cast< bool >(val2);
26050 {
26051 PyThreadState* __tstate = wxPyBeginAllowThreads();
26052 (arg1)->SetDirection(arg2);
26053 wxPyEndAllowThreads(__tstate);
26054 if (PyErr_Occurred()) SWIG_fail;
26055 }
26056 resultobj = SWIG_Py_Void();
26057 return resultobj;
26058 fail:
26059 return NULL;
26060 }
26061
26062
26063 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26064 PyObject *resultobj = 0;
26065 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26066 bool result;
26067 void *argp1 = 0 ;
26068 int res1 = 0 ;
26069 PyObject *swig_obj[1] ;
26070
26071 if (!args) SWIG_fail;
26072 swig_obj[0] = args;
26073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26074 if (!SWIG_IsOK(res1)) {
26075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26076 }
26077 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26078 {
26079 PyThreadState* __tstate = wxPyBeginAllowThreads();
26080 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
26081 wxPyEndAllowThreads(__tstate);
26082 if (PyErr_Occurred()) SWIG_fail;
26083 }
26084 {
26085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26086 }
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26094 PyObject *resultobj = 0;
26095 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26096 bool arg2 ;
26097 void *argp1 = 0 ;
26098 int res1 = 0 ;
26099 bool val2 ;
26100 int ecode2 = 0 ;
26101 PyObject * obj0 = 0 ;
26102 PyObject * obj1 = 0 ;
26103 char * kwnames[] = {
26104 (char *) "self",(char *) "ischange", NULL
26105 };
26106
26107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
26108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26109 if (!SWIG_IsOK(res1)) {
26110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26111 }
26112 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26113 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26114 if (!SWIG_IsOK(ecode2)) {
26115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
26116 }
26117 arg2 = static_cast< bool >(val2);
26118 {
26119 PyThreadState* __tstate = wxPyBeginAllowThreads();
26120 (arg1)->SetWindowChange(arg2);
26121 wxPyEndAllowThreads(__tstate);
26122 if (PyErr_Occurred()) SWIG_fail;
26123 }
26124 resultobj = SWIG_Py_Void();
26125 return resultobj;
26126 fail:
26127 return NULL;
26128 }
26129
26130
26131 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26132 PyObject *resultobj = 0;
26133 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26134 bool result;
26135 void *argp1 = 0 ;
26136 int res1 = 0 ;
26137 PyObject *swig_obj[1] ;
26138
26139 if (!args) SWIG_fail;
26140 swig_obj[0] = args;
26141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26142 if (!SWIG_IsOK(res1)) {
26143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26144 }
26145 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26146 {
26147 PyThreadState* __tstate = wxPyBeginAllowThreads();
26148 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
26149 wxPyEndAllowThreads(__tstate);
26150 if (PyErr_Occurred()) SWIG_fail;
26151 }
26152 {
26153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26154 }
26155 return resultobj;
26156 fail:
26157 return NULL;
26158 }
26159
26160
26161 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26162 PyObject *resultobj = 0;
26163 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26164 bool arg2 ;
26165 void *argp1 = 0 ;
26166 int res1 = 0 ;
26167 bool val2 ;
26168 int ecode2 = 0 ;
26169 PyObject * obj0 = 0 ;
26170 PyObject * obj1 = 0 ;
26171 char * kwnames[] = {
26172 (char *) "self",(char *) "bIs", NULL
26173 };
26174
26175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
26176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26177 if (!SWIG_IsOK(res1)) {
26178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26179 }
26180 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26181 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26182 if (!SWIG_IsOK(ecode2)) {
26183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
26184 }
26185 arg2 = static_cast< bool >(val2);
26186 {
26187 PyThreadState* __tstate = wxPyBeginAllowThreads();
26188 (arg1)->SetFromTab(arg2);
26189 wxPyEndAllowThreads(__tstate);
26190 if (PyErr_Occurred()) SWIG_fail;
26191 }
26192 resultobj = SWIG_Py_Void();
26193 return resultobj;
26194 fail:
26195 return NULL;
26196 }
26197
26198
26199 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26200 PyObject *resultobj = 0;
26201 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26202 long arg2 ;
26203 void *argp1 = 0 ;
26204 int res1 = 0 ;
26205 long val2 ;
26206 int ecode2 = 0 ;
26207 PyObject * obj0 = 0 ;
26208 PyObject * obj1 = 0 ;
26209 char * kwnames[] = {
26210 (char *) "self",(char *) "flags", NULL
26211 };
26212
26213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26215 if (!SWIG_IsOK(res1)) {
26216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26217 }
26218 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26219 ecode2 = SWIG_AsVal_long(obj1, &val2);
26220 if (!SWIG_IsOK(ecode2)) {
26221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26222 }
26223 arg2 = static_cast< long >(val2);
26224 {
26225 PyThreadState* __tstate = wxPyBeginAllowThreads();
26226 (arg1)->SetFlags(arg2);
26227 wxPyEndAllowThreads(__tstate);
26228 if (PyErr_Occurred()) SWIG_fail;
26229 }
26230 resultobj = SWIG_Py_Void();
26231 return resultobj;
26232 fail:
26233 return NULL;
26234 }
26235
26236
26237 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26238 PyObject *resultobj = 0;
26239 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26240 wxWindow *result = 0 ;
26241 void *argp1 = 0 ;
26242 int res1 = 0 ;
26243 PyObject *swig_obj[1] ;
26244
26245 if (!args) SWIG_fail;
26246 swig_obj[0] = args;
26247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26248 if (!SWIG_IsOK(res1)) {
26249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26250 }
26251 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26252 {
26253 PyThreadState* __tstate = wxPyBeginAllowThreads();
26254 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26255 wxPyEndAllowThreads(__tstate);
26256 if (PyErr_Occurred()) SWIG_fail;
26257 }
26258 {
26259 resultobj = wxPyMake_wxObject(result, (bool)0);
26260 }
26261 return resultobj;
26262 fail:
26263 return NULL;
26264 }
26265
26266
26267 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26268 PyObject *resultobj = 0;
26269 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26270 wxWindow *arg2 = (wxWindow *) 0 ;
26271 void *argp1 = 0 ;
26272 int res1 = 0 ;
26273 void *argp2 = 0 ;
26274 int res2 = 0 ;
26275 PyObject * obj0 = 0 ;
26276 PyObject * obj1 = 0 ;
26277 char * kwnames[] = {
26278 (char *) "self",(char *) "win", NULL
26279 };
26280
26281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26283 if (!SWIG_IsOK(res1)) {
26284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26285 }
26286 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26287 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26288 if (!SWIG_IsOK(res2)) {
26289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26290 }
26291 arg2 = reinterpret_cast< wxWindow * >(argp2);
26292 {
26293 PyThreadState* __tstate = wxPyBeginAllowThreads();
26294 (arg1)->SetCurrentFocus(arg2);
26295 wxPyEndAllowThreads(__tstate);
26296 if (PyErr_Occurred()) SWIG_fail;
26297 }
26298 resultobj = SWIG_Py_Void();
26299 return resultobj;
26300 fail:
26301 return NULL;
26302 }
26303
26304
26305 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26306 PyObject *obj;
26307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26308 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26309 return SWIG_Py_Void();
26310 }
26311
26312 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26313 return SWIG_Python_InitShadowInstance(args);
26314 }
26315
26316 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26317 PyObject *resultobj = 0;
26318 wxWindow *arg1 = (wxWindow *) NULL ;
26319 wxWindowCreateEvent *result = 0 ;
26320 void *argp1 = 0 ;
26321 int res1 = 0 ;
26322 PyObject * obj0 = 0 ;
26323 char * kwnames[] = {
26324 (char *) "win", NULL
26325 };
26326
26327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26328 if (obj0) {
26329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26330 if (!SWIG_IsOK(res1)) {
26331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26332 }
26333 arg1 = reinterpret_cast< wxWindow * >(argp1);
26334 }
26335 {
26336 PyThreadState* __tstate = wxPyBeginAllowThreads();
26337 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26338 wxPyEndAllowThreads(__tstate);
26339 if (PyErr_Occurred()) SWIG_fail;
26340 }
26341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26342 return resultobj;
26343 fail:
26344 return NULL;
26345 }
26346
26347
26348 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26349 PyObject *resultobj = 0;
26350 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26351 wxWindow *result = 0 ;
26352 void *argp1 = 0 ;
26353 int res1 = 0 ;
26354 PyObject *swig_obj[1] ;
26355
26356 if (!args) SWIG_fail;
26357 swig_obj[0] = args;
26358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26359 if (!SWIG_IsOK(res1)) {
26360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26361 }
26362 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26363 {
26364 PyThreadState* __tstate = wxPyBeginAllowThreads();
26365 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26366 wxPyEndAllowThreads(__tstate);
26367 if (PyErr_Occurred()) SWIG_fail;
26368 }
26369 {
26370 resultobj = wxPyMake_wxObject(result, (bool)0);
26371 }
26372 return resultobj;
26373 fail:
26374 return NULL;
26375 }
26376
26377
26378 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26379 PyObject *obj;
26380 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26381 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26382 return SWIG_Py_Void();
26383 }
26384
26385 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26386 return SWIG_Python_InitShadowInstance(args);
26387 }
26388
26389 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26390 PyObject *resultobj = 0;
26391 wxWindow *arg1 = (wxWindow *) NULL ;
26392 wxWindowDestroyEvent *result = 0 ;
26393 void *argp1 = 0 ;
26394 int res1 = 0 ;
26395 PyObject * obj0 = 0 ;
26396 char * kwnames[] = {
26397 (char *) "win", NULL
26398 };
26399
26400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26401 if (obj0) {
26402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26403 if (!SWIG_IsOK(res1)) {
26404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26405 }
26406 arg1 = reinterpret_cast< wxWindow * >(argp1);
26407 }
26408 {
26409 PyThreadState* __tstate = wxPyBeginAllowThreads();
26410 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26411 wxPyEndAllowThreads(__tstate);
26412 if (PyErr_Occurred()) SWIG_fail;
26413 }
26414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26415 return resultobj;
26416 fail:
26417 return NULL;
26418 }
26419
26420
26421 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26422 PyObject *resultobj = 0;
26423 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26424 wxWindow *result = 0 ;
26425 void *argp1 = 0 ;
26426 int res1 = 0 ;
26427 PyObject *swig_obj[1] ;
26428
26429 if (!args) SWIG_fail;
26430 swig_obj[0] = args;
26431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26432 if (!SWIG_IsOK(res1)) {
26433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26434 }
26435 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26436 {
26437 PyThreadState* __tstate = wxPyBeginAllowThreads();
26438 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26439 wxPyEndAllowThreads(__tstate);
26440 if (PyErr_Occurred()) SWIG_fail;
26441 }
26442 {
26443 resultobj = wxPyMake_wxObject(result, (bool)0);
26444 }
26445 return resultobj;
26446 fail:
26447 return NULL;
26448 }
26449
26450
26451 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26452 PyObject *obj;
26453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26454 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26455 return SWIG_Py_Void();
26456 }
26457
26458 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26459 return SWIG_Python_InitShadowInstance(args);
26460 }
26461
26462 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26463 PyObject *resultobj = 0;
26464 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26465 int arg2 = (int) 0 ;
26466 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26467 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26468 wxContextMenuEvent *result = 0 ;
26469 int val1 ;
26470 int ecode1 = 0 ;
26471 int val2 ;
26472 int ecode2 = 0 ;
26473 wxPoint temp3 ;
26474 PyObject * obj0 = 0 ;
26475 PyObject * obj1 = 0 ;
26476 PyObject * obj2 = 0 ;
26477 char * kwnames[] = {
26478 (char *) "type",(char *) "winid",(char *) "pt", NULL
26479 };
26480
26481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26482 if (obj0) {
26483 ecode1 = SWIG_AsVal_int(obj0, &val1);
26484 if (!SWIG_IsOK(ecode1)) {
26485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26486 }
26487 arg1 = static_cast< wxEventType >(val1);
26488 }
26489 if (obj1) {
26490 ecode2 = SWIG_AsVal_int(obj1, &val2);
26491 if (!SWIG_IsOK(ecode2)) {
26492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26493 }
26494 arg2 = static_cast< int >(val2);
26495 }
26496 if (obj2) {
26497 {
26498 arg3 = &temp3;
26499 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26500 }
26501 }
26502 {
26503 PyThreadState* __tstate = wxPyBeginAllowThreads();
26504 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26505 wxPyEndAllowThreads(__tstate);
26506 if (PyErr_Occurred()) SWIG_fail;
26507 }
26508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26509 return resultobj;
26510 fail:
26511 return NULL;
26512 }
26513
26514
26515 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26516 PyObject *resultobj = 0;
26517 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26518 wxPoint *result = 0 ;
26519 void *argp1 = 0 ;
26520 int res1 = 0 ;
26521 PyObject *swig_obj[1] ;
26522
26523 if (!args) SWIG_fail;
26524 swig_obj[0] = args;
26525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26526 if (!SWIG_IsOK(res1)) {
26527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26528 }
26529 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26530 {
26531 PyThreadState* __tstate = wxPyBeginAllowThreads();
26532 {
26533 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26534 result = (wxPoint *) &_result_ref;
26535 }
26536 wxPyEndAllowThreads(__tstate);
26537 if (PyErr_Occurred()) SWIG_fail;
26538 }
26539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26540 return resultobj;
26541 fail:
26542 return NULL;
26543 }
26544
26545
26546 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26547 PyObject *resultobj = 0;
26548 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26549 wxPoint *arg2 = 0 ;
26550 void *argp1 = 0 ;
26551 int res1 = 0 ;
26552 wxPoint temp2 ;
26553 PyObject * obj0 = 0 ;
26554 PyObject * obj1 = 0 ;
26555 char * kwnames[] = {
26556 (char *) "self",(char *) "pos", NULL
26557 };
26558
26559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26561 if (!SWIG_IsOK(res1)) {
26562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26563 }
26564 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26565 {
26566 arg2 = &temp2;
26567 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26568 }
26569 {
26570 PyThreadState* __tstate = wxPyBeginAllowThreads();
26571 (arg1)->SetPosition((wxPoint const &)*arg2);
26572 wxPyEndAllowThreads(__tstate);
26573 if (PyErr_Occurred()) SWIG_fail;
26574 }
26575 resultobj = SWIG_Py_Void();
26576 return resultobj;
26577 fail:
26578 return NULL;
26579 }
26580
26581
26582 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26583 PyObject *obj;
26584 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26585 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26586 return SWIG_Py_Void();
26587 }
26588
26589 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26590 return SWIG_Python_InitShadowInstance(args);
26591 }
26592
26593 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26594 PyObject *resultobj = 0;
26595 wxIdleEvent *result = 0 ;
26596
26597 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26598 {
26599 PyThreadState* __tstate = wxPyBeginAllowThreads();
26600 result = (wxIdleEvent *)new wxIdleEvent();
26601 wxPyEndAllowThreads(__tstate);
26602 if (PyErr_Occurred()) SWIG_fail;
26603 }
26604 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26605 return resultobj;
26606 fail:
26607 return NULL;
26608 }
26609
26610
26611 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26612 PyObject *resultobj = 0;
26613 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26614 bool arg2 = (bool) true ;
26615 void *argp1 = 0 ;
26616 int res1 = 0 ;
26617 bool val2 ;
26618 int ecode2 = 0 ;
26619 PyObject * obj0 = 0 ;
26620 PyObject * obj1 = 0 ;
26621 char * kwnames[] = {
26622 (char *) "self",(char *) "needMore", NULL
26623 };
26624
26625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26627 if (!SWIG_IsOK(res1)) {
26628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26629 }
26630 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26631 if (obj1) {
26632 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26633 if (!SWIG_IsOK(ecode2)) {
26634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26635 }
26636 arg2 = static_cast< bool >(val2);
26637 }
26638 {
26639 PyThreadState* __tstate = wxPyBeginAllowThreads();
26640 (arg1)->RequestMore(arg2);
26641 wxPyEndAllowThreads(__tstate);
26642 if (PyErr_Occurred()) SWIG_fail;
26643 }
26644 resultobj = SWIG_Py_Void();
26645 return resultobj;
26646 fail:
26647 return NULL;
26648 }
26649
26650
26651 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26652 PyObject *resultobj = 0;
26653 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26654 bool result;
26655 void *argp1 = 0 ;
26656 int res1 = 0 ;
26657 PyObject *swig_obj[1] ;
26658
26659 if (!args) SWIG_fail;
26660 swig_obj[0] = args;
26661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26662 if (!SWIG_IsOK(res1)) {
26663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26664 }
26665 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26666 {
26667 PyThreadState* __tstate = wxPyBeginAllowThreads();
26668 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26669 wxPyEndAllowThreads(__tstate);
26670 if (PyErr_Occurred()) SWIG_fail;
26671 }
26672 {
26673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26674 }
26675 return resultobj;
26676 fail:
26677 return NULL;
26678 }
26679
26680
26681 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26682 PyObject *resultobj = 0;
26683 wxIdleMode arg1 ;
26684 int val1 ;
26685 int ecode1 = 0 ;
26686 PyObject * obj0 = 0 ;
26687 char * kwnames[] = {
26688 (char *) "mode", NULL
26689 };
26690
26691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26692 ecode1 = SWIG_AsVal_int(obj0, &val1);
26693 if (!SWIG_IsOK(ecode1)) {
26694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26695 }
26696 arg1 = static_cast< wxIdleMode >(val1);
26697 {
26698 PyThreadState* __tstate = wxPyBeginAllowThreads();
26699 wxIdleEvent::SetMode(arg1);
26700 wxPyEndAllowThreads(__tstate);
26701 if (PyErr_Occurred()) SWIG_fail;
26702 }
26703 resultobj = SWIG_Py_Void();
26704 return resultobj;
26705 fail:
26706 return NULL;
26707 }
26708
26709
26710 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26711 PyObject *resultobj = 0;
26712 wxIdleMode result;
26713
26714 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26715 {
26716 PyThreadState* __tstate = wxPyBeginAllowThreads();
26717 result = (wxIdleMode)wxIdleEvent::GetMode();
26718 wxPyEndAllowThreads(__tstate);
26719 if (PyErr_Occurred()) SWIG_fail;
26720 }
26721 resultobj = SWIG_From_int(static_cast< int >(result));
26722 return resultobj;
26723 fail:
26724 return NULL;
26725 }
26726
26727
26728 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26729 PyObject *resultobj = 0;
26730 wxWindow *arg1 = (wxWindow *) 0 ;
26731 bool result;
26732 void *argp1 = 0 ;
26733 int res1 = 0 ;
26734 PyObject * obj0 = 0 ;
26735 char * kwnames[] = {
26736 (char *) "win", NULL
26737 };
26738
26739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26741 if (!SWIG_IsOK(res1)) {
26742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26743 }
26744 arg1 = reinterpret_cast< wxWindow * >(argp1);
26745 {
26746 PyThreadState* __tstate = wxPyBeginAllowThreads();
26747 result = (bool)wxIdleEvent::CanSend(arg1);
26748 wxPyEndAllowThreads(__tstate);
26749 if (PyErr_Occurred()) SWIG_fail;
26750 }
26751 {
26752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26753 }
26754 return resultobj;
26755 fail:
26756 return NULL;
26757 }
26758
26759
26760 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26761 PyObject *obj;
26762 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26763 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26764 return SWIG_Py_Void();
26765 }
26766
26767 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26768 return SWIG_Python_InitShadowInstance(args);
26769 }
26770
26771 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26772 PyObject *resultobj = 0;
26773 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26774 int arg2 = (int) 0 ;
26775 wxClipboardTextEvent *result = 0 ;
26776 int val1 ;
26777 int ecode1 = 0 ;
26778 int val2 ;
26779 int ecode2 = 0 ;
26780 PyObject * obj0 = 0 ;
26781 PyObject * obj1 = 0 ;
26782 char * kwnames[] = {
26783 (char *) "type",(char *) "winid", NULL
26784 };
26785
26786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26787 if (obj0) {
26788 ecode1 = SWIG_AsVal_int(obj0, &val1);
26789 if (!SWIG_IsOK(ecode1)) {
26790 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26791 }
26792 arg1 = static_cast< wxEventType >(val1);
26793 }
26794 if (obj1) {
26795 ecode2 = SWIG_AsVal_int(obj1, &val2);
26796 if (!SWIG_IsOK(ecode2)) {
26797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26798 }
26799 arg2 = static_cast< int >(val2);
26800 }
26801 {
26802 PyThreadState* __tstate = wxPyBeginAllowThreads();
26803 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26804 wxPyEndAllowThreads(__tstate);
26805 if (PyErr_Occurred()) SWIG_fail;
26806 }
26807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26808 return resultobj;
26809 fail:
26810 return NULL;
26811 }
26812
26813
26814 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26815 PyObject *obj;
26816 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26817 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26818 return SWIG_Py_Void();
26819 }
26820
26821 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26822 return SWIG_Python_InitShadowInstance(args);
26823 }
26824
26825 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26826 PyObject *resultobj = 0;
26827 int arg1 = (int) 0 ;
26828 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26829 wxPyEvent *result = 0 ;
26830 int val1 ;
26831 int ecode1 = 0 ;
26832 int val2 ;
26833 int ecode2 = 0 ;
26834 PyObject * obj0 = 0 ;
26835 PyObject * obj1 = 0 ;
26836 char * kwnames[] = {
26837 (char *) "winid",(char *) "eventType", NULL
26838 };
26839
26840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26841 if (obj0) {
26842 ecode1 = SWIG_AsVal_int(obj0, &val1);
26843 if (!SWIG_IsOK(ecode1)) {
26844 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26845 }
26846 arg1 = static_cast< int >(val1);
26847 }
26848 if (obj1) {
26849 ecode2 = SWIG_AsVal_int(obj1, &val2);
26850 if (!SWIG_IsOK(ecode2)) {
26851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26852 }
26853 arg2 = static_cast< wxEventType >(val2);
26854 }
26855 {
26856 PyThreadState* __tstate = wxPyBeginAllowThreads();
26857 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26858 wxPyEndAllowThreads(__tstate);
26859 if (PyErr_Occurred()) SWIG_fail;
26860 }
26861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26862 return resultobj;
26863 fail:
26864 return NULL;
26865 }
26866
26867
26868 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26869 PyObject *resultobj = 0;
26870 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26871 void *argp1 = 0 ;
26872 int res1 = 0 ;
26873 PyObject *swig_obj[1] ;
26874
26875 if (!args) SWIG_fail;
26876 swig_obj[0] = args;
26877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26878 if (!SWIG_IsOK(res1)) {
26879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26880 }
26881 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26882 {
26883 PyThreadState* __tstate = wxPyBeginAllowThreads();
26884 delete arg1;
26885
26886 wxPyEndAllowThreads(__tstate);
26887 if (PyErr_Occurred()) SWIG_fail;
26888 }
26889 resultobj = SWIG_Py_Void();
26890 return resultobj;
26891 fail:
26892 return NULL;
26893 }
26894
26895
26896 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26897 PyObject *resultobj = 0;
26898 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26899 PyObject *arg2 = (PyObject *) 0 ;
26900 void *argp1 = 0 ;
26901 int res1 = 0 ;
26902 PyObject * obj0 = 0 ;
26903 PyObject * obj1 = 0 ;
26904 char * kwnames[] = {
26905 (char *) "self",(char *) "self", NULL
26906 };
26907
26908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26910 if (!SWIG_IsOK(res1)) {
26911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26912 }
26913 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26914 arg2 = obj1;
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 (arg1)->SetSelf(arg2);
26918 wxPyEndAllowThreads(__tstate);
26919 if (PyErr_Occurred()) SWIG_fail;
26920 }
26921 resultobj = SWIG_Py_Void();
26922 return resultobj;
26923 fail:
26924 return NULL;
26925 }
26926
26927
26928 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26929 PyObject *resultobj = 0;
26930 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26931 PyObject *result = 0 ;
26932 void *argp1 = 0 ;
26933 int res1 = 0 ;
26934 PyObject *swig_obj[1] ;
26935
26936 if (!args) SWIG_fail;
26937 swig_obj[0] = args;
26938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26939 if (!SWIG_IsOK(res1)) {
26940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26941 }
26942 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26943 {
26944 PyThreadState* __tstate = wxPyBeginAllowThreads();
26945 result = (PyObject *)(arg1)->GetSelf();
26946 wxPyEndAllowThreads(__tstate);
26947 if (PyErr_Occurred()) SWIG_fail;
26948 }
26949 resultobj = result;
26950 return resultobj;
26951 fail:
26952 return NULL;
26953 }
26954
26955
26956 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26957 PyObject *obj;
26958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26959 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26960 return SWIG_Py_Void();
26961 }
26962
26963 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26964 return SWIG_Python_InitShadowInstance(args);
26965 }
26966
26967 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26968 PyObject *resultobj = 0;
26969 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26970 int arg2 = (int) 0 ;
26971 wxPyCommandEvent *result = 0 ;
26972 int val1 ;
26973 int ecode1 = 0 ;
26974 int val2 ;
26975 int ecode2 = 0 ;
26976 PyObject * obj0 = 0 ;
26977 PyObject * obj1 = 0 ;
26978 char * kwnames[] = {
26979 (char *) "eventType",(char *) "id", NULL
26980 };
26981
26982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26983 if (obj0) {
26984 ecode1 = SWIG_AsVal_int(obj0, &val1);
26985 if (!SWIG_IsOK(ecode1)) {
26986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26987 }
26988 arg1 = static_cast< wxEventType >(val1);
26989 }
26990 if (obj1) {
26991 ecode2 = SWIG_AsVal_int(obj1, &val2);
26992 if (!SWIG_IsOK(ecode2)) {
26993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26994 }
26995 arg2 = static_cast< int >(val2);
26996 }
26997 {
26998 PyThreadState* __tstate = wxPyBeginAllowThreads();
26999 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
27000 wxPyEndAllowThreads(__tstate);
27001 if (PyErr_Occurred()) SWIG_fail;
27002 }
27003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
27004 return resultobj;
27005 fail:
27006 return NULL;
27007 }
27008
27009
27010 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27011 PyObject *resultobj = 0;
27012 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27013 void *argp1 = 0 ;
27014 int res1 = 0 ;
27015 PyObject *swig_obj[1] ;
27016
27017 if (!args) SWIG_fail;
27018 swig_obj[0] = args;
27019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
27020 if (!SWIG_IsOK(res1)) {
27021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27022 }
27023 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27024 {
27025 PyThreadState* __tstate = wxPyBeginAllowThreads();
27026 delete arg1;
27027
27028 wxPyEndAllowThreads(__tstate);
27029 if (PyErr_Occurred()) SWIG_fail;
27030 }
27031 resultobj = SWIG_Py_Void();
27032 return resultobj;
27033 fail:
27034 return NULL;
27035 }
27036
27037
27038 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27039 PyObject *resultobj = 0;
27040 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27041 PyObject *arg2 = (PyObject *) 0 ;
27042 void *argp1 = 0 ;
27043 int res1 = 0 ;
27044 PyObject * obj0 = 0 ;
27045 PyObject * obj1 = 0 ;
27046 char * kwnames[] = {
27047 (char *) "self",(char *) "self", NULL
27048 };
27049
27050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
27051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27052 if (!SWIG_IsOK(res1)) {
27053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27054 }
27055 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27056 arg2 = obj1;
27057 {
27058 PyThreadState* __tstate = wxPyBeginAllowThreads();
27059 (arg1)->SetSelf(arg2);
27060 wxPyEndAllowThreads(__tstate);
27061 if (PyErr_Occurred()) SWIG_fail;
27062 }
27063 resultobj = SWIG_Py_Void();
27064 return resultobj;
27065 fail:
27066 return NULL;
27067 }
27068
27069
27070 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27071 PyObject *resultobj = 0;
27072 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
27073 PyObject *result = 0 ;
27074 void *argp1 = 0 ;
27075 int res1 = 0 ;
27076 PyObject *swig_obj[1] ;
27077
27078 if (!args) SWIG_fail;
27079 swig_obj[0] = args;
27080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
27081 if (!SWIG_IsOK(res1)) {
27082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
27083 }
27084 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
27085 {
27086 PyThreadState* __tstate = wxPyBeginAllowThreads();
27087 result = (PyObject *)(arg1)->GetSelf();
27088 wxPyEndAllowThreads(__tstate);
27089 if (PyErr_Occurred()) SWIG_fail;
27090 }
27091 resultobj = result;
27092 return resultobj;
27093 fail:
27094 return NULL;
27095 }
27096
27097
27098 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27099 PyObject *obj;
27100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27101 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
27102 return SWIG_Py_Void();
27103 }
27104
27105 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27106 return SWIG_Python_InitShadowInstance(args);
27107 }
27108
27109 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27110 PyObject *resultobj = 0;
27111 wxWindow *arg1 = (wxWindow *) 0 ;
27112 wxDateTime *arg2 = 0 ;
27113 wxEventType arg3 ;
27114 wxDateEvent *result = 0 ;
27115 void *argp1 = 0 ;
27116 int res1 = 0 ;
27117 void *argp2 = 0 ;
27118 int res2 = 0 ;
27119 int val3 ;
27120 int ecode3 = 0 ;
27121 PyObject * obj0 = 0 ;
27122 PyObject * obj1 = 0 ;
27123 PyObject * obj2 = 0 ;
27124 char * kwnames[] = {
27125 (char *) "win",(char *) "dt",(char *) "type", NULL
27126 };
27127
27128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27130 if (!SWIG_IsOK(res1)) {
27131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27132 }
27133 arg1 = reinterpret_cast< wxWindow * >(argp1);
27134 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27135 if (!SWIG_IsOK(res2)) {
27136 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27137 }
27138 if (!argp2) {
27139 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27140 }
27141 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27142 ecode3 = SWIG_AsVal_int(obj2, &val3);
27143 if (!SWIG_IsOK(ecode3)) {
27144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
27145 }
27146 arg3 = static_cast< wxEventType >(val3);
27147 {
27148 PyThreadState* __tstate = wxPyBeginAllowThreads();
27149 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
27150 wxPyEndAllowThreads(__tstate);
27151 if (PyErr_Occurred()) SWIG_fail;
27152 }
27153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
27154 return resultobj;
27155 fail:
27156 return NULL;
27157 }
27158
27159
27160 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27161 PyObject *resultobj = 0;
27162 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27163 wxDateTime *result = 0 ;
27164 void *argp1 = 0 ;
27165 int res1 = 0 ;
27166 PyObject *swig_obj[1] ;
27167
27168 if (!args) SWIG_fail;
27169 swig_obj[0] = args;
27170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27171 if (!SWIG_IsOK(res1)) {
27172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
27173 }
27174 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27175 {
27176 PyThreadState* __tstate = wxPyBeginAllowThreads();
27177 {
27178 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
27179 result = (wxDateTime *) &_result_ref;
27180 }
27181 wxPyEndAllowThreads(__tstate);
27182 if (PyErr_Occurred()) SWIG_fail;
27183 }
27184 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
27185 return resultobj;
27186 fail:
27187 return NULL;
27188 }
27189
27190
27191 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27192 PyObject *resultobj = 0;
27193 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
27194 wxDateTime *arg2 = 0 ;
27195 void *argp1 = 0 ;
27196 int res1 = 0 ;
27197 void *argp2 = 0 ;
27198 int res2 = 0 ;
27199 PyObject * obj0 = 0 ;
27200 PyObject * obj1 = 0 ;
27201 char * kwnames[] = {
27202 (char *) "self",(char *) "date", NULL
27203 };
27204
27205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27207 if (!SWIG_IsOK(res1)) {
27208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27209 }
27210 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27211 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27212 if (!SWIG_IsOK(res2)) {
27213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27214 }
27215 if (!argp2) {
27216 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27217 }
27218 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27219 {
27220 PyThreadState* __tstate = wxPyBeginAllowThreads();
27221 (arg1)->SetDate((wxDateTime const &)*arg2);
27222 wxPyEndAllowThreads(__tstate);
27223 if (PyErr_Occurred()) SWIG_fail;
27224 }
27225 resultobj = SWIG_Py_Void();
27226 return resultobj;
27227 fail:
27228 return NULL;
27229 }
27230
27231
27232 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27233 PyObject *obj;
27234 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27235 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27236 return SWIG_Py_Void();
27237 }
27238
27239 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27240 return SWIG_Python_InitShadowInstance(args);
27241 }
27242
27243 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27244 PyObject *resultobj = 0;
27245 wxPyApp *result = 0 ;
27246
27247 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27248 {
27249 PyThreadState* __tstate = wxPyBeginAllowThreads();
27250 result = (wxPyApp *)new_wxPyApp();
27251 wxPyEndAllowThreads(__tstate);
27252 if (PyErr_Occurred()) SWIG_fail;
27253 }
27254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27255 return resultobj;
27256 fail:
27257 return NULL;
27258 }
27259
27260
27261 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27262 PyObject *resultobj = 0;
27263 wxPyApp *arg1 = (wxPyApp *) 0 ;
27264 void *argp1 = 0 ;
27265 int res1 = 0 ;
27266 PyObject *swig_obj[1] ;
27267
27268 if (!args) SWIG_fail;
27269 swig_obj[0] = args;
27270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27271 if (!SWIG_IsOK(res1)) {
27272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27273 }
27274 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27275 {
27276 PyThreadState* __tstate = wxPyBeginAllowThreads();
27277 delete arg1;
27278
27279 wxPyEndAllowThreads(__tstate);
27280 if (PyErr_Occurred()) SWIG_fail;
27281 }
27282 resultobj = SWIG_Py_Void();
27283 return resultobj;
27284 fail:
27285 return NULL;
27286 }
27287
27288
27289 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27290 PyObject *resultobj = 0;
27291 wxPyApp *arg1 = (wxPyApp *) 0 ;
27292 PyObject *arg2 = (PyObject *) 0 ;
27293 PyObject *arg3 = (PyObject *) 0 ;
27294 bool arg4 ;
27295 void *argp1 = 0 ;
27296 int res1 = 0 ;
27297 bool val4 ;
27298 int ecode4 = 0 ;
27299 PyObject * obj0 = 0 ;
27300 PyObject * obj1 = 0 ;
27301 PyObject * obj2 = 0 ;
27302 PyObject * obj3 = 0 ;
27303 char * kwnames[] = {
27304 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27305 };
27306
27307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27309 if (!SWIG_IsOK(res1)) {
27310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27311 }
27312 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27313 arg2 = obj1;
27314 arg3 = obj2;
27315 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27316 if (!SWIG_IsOK(ecode4)) {
27317 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27318 }
27319 arg4 = static_cast< bool >(val4);
27320 {
27321 PyThreadState* __tstate = wxPyBeginAllowThreads();
27322 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27323 wxPyEndAllowThreads(__tstate);
27324 if (PyErr_Occurred()) SWIG_fail;
27325 }
27326 resultobj = SWIG_Py_Void();
27327 return resultobj;
27328 fail:
27329 return NULL;
27330 }
27331
27332
27333 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27334 PyObject *resultobj = 0;
27335 wxPyApp *arg1 = (wxPyApp *) 0 ;
27336 wxString result;
27337 void *argp1 = 0 ;
27338 int res1 = 0 ;
27339 PyObject *swig_obj[1] ;
27340
27341 if (!args) SWIG_fail;
27342 swig_obj[0] = args;
27343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27344 if (!SWIG_IsOK(res1)) {
27345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27346 }
27347 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27348 {
27349 PyThreadState* __tstate = wxPyBeginAllowThreads();
27350 result = ((wxPyApp const *)arg1)->GetAppName();
27351 wxPyEndAllowThreads(__tstate);
27352 if (PyErr_Occurred()) SWIG_fail;
27353 }
27354 {
27355 #if wxUSE_UNICODE
27356 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27357 #else
27358 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27359 #endif
27360 }
27361 return resultobj;
27362 fail:
27363 return NULL;
27364 }
27365
27366
27367 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27368 PyObject *resultobj = 0;
27369 wxPyApp *arg1 = (wxPyApp *) 0 ;
27370 wxString *arg2 = 0 ;
27371 void *argp1 = 0 ;
27372 int res1 = 0 ;
27373 bool temp2 = false ;
27374 PyObject * obj0 = 0 ;
27375 PyObject * obj1 = 0 ;
27376 char * kwnames[] = {
27377 (char *) "self",(char *) "name", NULL
27378 };
27379
27380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27382 if (!SWIG_IsOK(res1)) {
27383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27384 }
27385 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27386 {
27387 arg2 = wxString_in_helper(obj1);
27388 if (arg2 == NULL) SWIG_fail;
27389 temp2 = true;
27390 }
27391 {
27392 PyThreadState* __tstate = wxPyBeginAllowThreads();
27393 (arg1)->SetAppName((wxString const &)*arg2);
27394 wxPyEndAllowThreads(__tstate);
27395 if (PyErr_Occurred()) SWIG_fail;
27396 }
27397 resultobj = SWIG_Py_Void();
27398 {
27399 if (temp2)
27400 delete arg2;
27401 }
27402 return resultobj;
27403 fail:
27404 {
27405 if (temp2)
27406 delete arg2;
27407 }
27408 return NULL;
27409 }
27410
27411
27412 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27413 PyObject *resultobj = 0;
27414 wxPyApp *arg1 = (wxPyApp *) 0 ;
27415 wxString result;
27416 void *argp1 = 0 ;
27417 int res1 = 0 ;
27418 PyObject *swig_obj[1] ;
27419
27420 if (!args) SWIG_fail;
27421 swig_obj[0] = args;
27422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27423 if (!SWIG_IsOK(res1)) {
27424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27425 }
27426 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27427 {
27428 PyThreadState* __tstate = wxPyBeginAllowThreads();
27429 result = ((wxPyApp const *)arg1)->GetClassName();
27430 wxPyEndAllowThreads(__tstate);
27431 if (PyErr_Occurred()) SWIG_fail;
27432 }
27433 {
27434 #if wxUSE_UNICODE
27435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27436 #else
27437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27438 #endif
27439 }
27440 return resultobj;
27441 fail:
27442 return NULL;
27443 }
27444
27445
27446 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27447 PyObject *resultobj = 0;
27448 wxPyApp *arg1 = (wxPyApp *) 0 ;
27449 wxString *arg2 = 0 ;
27450 void *argp1 = 0 ;
27451 int res1 = 0 ;
27452 bool temp2 = false ;
27453 PyObject * obj0 = 0 ;
27454 PyObject * obj1 = 0 ;
27455 char * kwnames[] = {
27456 (char *) "self",(char *) "name", NULL
27457 };
27458
27459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27461 if (!SWIG_IsOK(res1)) {
27462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27463 }
27464 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27465 {
27466 arg2 = wxString_in_helper(obj1);
27467 if (arg2 == NULL) SWIG_fail;
27468 temp2 = true;
27469 }
27470 {
27471 PyThreadState* __tstate = wxPyBeginAllowThreads();
27472 (arg1)->SetClassName((wxString const &)*arg2);
27473 wxPyEndAllowThreads(__tstate);
27474 if (PyErr_Occurred()) SWIG_fail;
27475 }
27476 resultobj = SWIG_Py_Void();
27477 {
27478 if (temp2)
27479 delete arg2;
27480 }
27481 return resultobj;
27482 fail:
27483 {
27484 if (temp2)
27485 delete arg2;
27486 }
27487 return NULL;
27488 }
27489
27490
27491 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27492 PyObject *resultobj = 0;
27493 wxPyApp *arg1 = (wxPyApp *) 0 ;
27494 wxString *result = 0 ;
27495 void *argp1 = 0 ;
27496 int res1 = 0 ;
27497 PyObject *swig_obj[1] ;
27498
27499 if (!args) SWIG_fail;
27500 swig_obj[0] = args;
27501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27502 if (!SWIG_IsOK(res1)) {
27503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27504 }
27505 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 {
27509 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27510 result = (wxString *) &_result_ref;
27511 }
27512 wxPyEndAllowThreads(__tstate);
27513 if (PyErr_Occurred()) SWIG_fail;
27514 }
27515 {
27516 #if wxUSE_UNICODE
27517 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27518 #else
27519 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27520 #endif
27521 }
27522 return resultobj;
27523 fail:
27524 return NULL;
27525 }
27526
27527
27528 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27529 PyObject *resultobj = 0;
27530 wxPyApp *arg1 = (wxPyApp *) 0 ;
27531 wxString *arg2 = 0 ;
27532 void *argp1 = 0 ;
27533 int res1 = 0 ;
27534 bool temp2 = false ;
27535 PyObject * obj0 = 0 ;
27536 PyObject * obj1 = 0 ;
27537 char * kwnames[] = {
27538 (char *) "self",(char *) "name", NULL
27539 };
27540
27541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27543 if (!SWIG_IsOK(res1)) {
27544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27545 }
27546 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27547 {
27548 arg2 = wxString_in_helper(obj1);
27549 if (arg2 == NULL) SWIG_fail;
27550 temp2 = true;
27551 }
27552 {
27553 PyThreadState* __tstate = wxPyBeginAllowThreads();
27554 (arg1)->SetVendorName((wxString const &)*arg2);
27555 wxPyEndAllowThreads(__tstate);
27556 if (PyErr_Occurred()) SWIG_fail;
27557 }
27558 resultobj = SWIG_Py_Void();
27559 {
27560 if (temp2)
27561 delete arg2;
27562 }
27563 return resultobj;
27564 fail:
27565 {
27566 if (temp2)
27567 delete arg2;
27568 }
27569 return NULL;
27570 }
27571
27572
27573 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27574 PyObject *resultobj = 0;
27575 wxPyApp *arg1 = (wxPyApp *) 0 ;
27576 wxAppTraits *result = 0 ;
27577 void *argp1 = 0 ;
27578 int res1 = 0 ;
27579 PyObject *swig_obj[1] ;
27580
27581 if (!args) SWIG_fail;
27582 swig_obj[0] = args;
27583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27584 if (!SWIG_IsOK(res1)) {
27585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27586 }
27587 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27588 {
27589 PyThreadState* __tstate = wxPyBeginAllowThreads();
27590 result = (wxAppTraits *)(arg1)->GetTraits();
27591 wxPyEndAllowThreads(__tstate);
27592 if (PyErr_Occurred()) SWIG_fail;
27593 }
27594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27595 return resultobj;
27596 fail:
27597 return NULL;
27598 }
27599
27600
27601 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27602 PyObject *resultobj = 0;
27603 wxPyApp *arg1 = (wxPyApp *) 0 ;
27604 void *argp1 = 0 ;
27605 int res1 = 0 ;
27606 PyObject *swig_obj[1] ;
27607
27608 if (!args) SWIG_fail;
27609 swig_obj[0] = args;
27610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27611 if (!SWIG_IsOK(res1)) {
27612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27613 }
27614 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27615 {
27616 PyThreadState* __tstate = wxPyBeginAllowThreads();
27617 (arg1)->ProcessPendingEvents();
27618 wxPyEndAllowThreads(__tstate);
27619 if (PyErr_Occurred()) SWIG_fail;
27620 }
27621 resultobj = SWIG_Py_Void();
27622 return resultobj;
27623 fail:
27624 return NULL;
27625 }
27626
27627
27628 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27629 PyObject *resultobj = 0;
27630 wxPyApp *arg1 = (wxPyApp *) 0 ;
27631 bool arg2 = (bool) false ;
27632 bool result;
27633 void *argp1 = 0 ;
27634 int res1 = 0 ;
27635 bool val2 ;
27636 int ecode2 = 0 ;
27637 PyObject * obj0 = 0 ;
27638 PyObject * obj1 = 0 ;
27639 char * kwnames[] = {
27640 (char *) "self",(char *) "onlyIfNeeded", NULL
27641 };
27642
27643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27645 if (!SWIG_IsOK(res1)) {
27646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27647 }
27648 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27649 if (obj1) {
27650 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27651 if (!SWIG_IsOK(ecode2)) {
27652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27653 }
27654 arg2 = static_cast< bool >(val2);
27655 }
27656 {
27657 PyThreadState* __tstate = wxPyBeginAllowThreads();
27658 result = (bool)(arg1)->Yield(arg2);
27659 wxPyEndAllowThreads(__tstate);
27660 if (PyErr_Occurred()) SWIG_fail;
27661 }
27662 {
27663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27664 }
27665 return resultobj;
27666 fail:
27667 return NULL;
27668 }
27669
27670
27671 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27672 PyObject *resultobj = 0;
27673 wxPyApp *arg1 = (wxPyApp *) 0 ;
27674 void *argp1 = 0 ;
27675 int res1 = 0 ;
27676 PyObject *swig_obj[1] ;
27677
27678 if (!args) SWIG_fail;
27679 swig_obj[0] = args;
27680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27681 if (!SWIG_IsOK(res1)) {
27682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27683 }
27684 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27685 {
27686 PyThreadState* __tstate = wxPyBeginAllowThreads();
27687 (arg1)->WakeUpIdle();
27688 wxPyEndAllowThreads(__tstate);
27689 if (PyErr_Occurred()) SWIG_fail;
27690 }
27691 resultobj = SWIG_Py_Void();
27692 return resultobj;
27693 fail:
27694 return NULL;
27695 }
27696
27697
27698 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27699 PyObject *resultobj = 0;
27700 bool result;
27701
27702 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27703 {
27704 PyThreadState* __tstate = wxPyBeginAllowThreads();
27705 result = (bool)wxPyApp::IsMainLoopRunning();
27706 wxPyEndAllowThreads(__tstate);
27707 if (PyErr_Occurred()) SWIG_fail;
27708 }
27709 {
27710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27711 }
27712 return resultobj;
27713 fail:
27714 return NULL;
27715 }
27716
27717
27718 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27719 PyObject *resultobj = 0;
27720 wxPyApp *arg1 = (wxPyApp *) 0 ;
27721 int result;
27722 void *argp1 = 0 ;
27723 int res1 = 0 ;
27724 PyObject *swig_obj[1] ;
27725
27726 if (!args) SWIG_fail;
27727 swig_obj[0] = args;
27728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27729 if (!SWIG_IsOK(res1)) {
27730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27731 }
27732 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 result = (int)(arg1)->MainLoop();
27736 wxPyEndAllowThreads(__tstate);
27737 if (PyErr_Occurred()) SWIG_fail;
27738 }
27739 resultobj = SWIG_From_int(static_cast< int >(result));
27740 return resultobj;
27741 fail:
27742 return NULL;
27743 }
27744
27745
27746 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27747 PyObject *resultobj = 0;
27748 wxPyApp *arg1 = (wxPyApp *) 0 ;
27749 void *argp1 = 0 ;
27750 int res1 = 0 ;
27751 PyObject *swig_obj[1] ;
27752
27753 if (!args) SWIG_fail;
27754 swig_obj[0] = args;
27755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27756 if (!SWIG_IsOK(res1)) {
27757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27758 }
27759 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27760 {
27761 PyThreadState* __tstate = wxPyBeginAllowThreads();
27762 (arg1)->Exit();
27763 wxPyEndAllowThreads(__tstate);
27764 if (PyErr_Occurred()) SWIG_fail;
27765 }
27766 resultobj = SWIG_Py_Void();
27767 return resultobj;
27768 fail:
27769 return NULL;
27770 }
27771
27772
27773 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27774 PyObject *resultobj = 0;
27775 wxPyApp *arg1 = (wxPyApp *) 0 ;
27776 wxLayoutDirection result;
27777 void *argp1 = 0 ;
27778 int res1 = 0 ;
27779 PyObject *swig_obj[1] ;
27780
27781 if (!args) SWIG_fail;
27782 swig_obj[0] = args;
27783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27784 if (!SWIG_IsOK(res1)) {
27785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27786 }
27787 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27788 {
27789 PyThreadState* __tstate = wxPyBeginAllowThreads();
27790 result = ((wxPyApp const *)arg1)->GetLayoutDirection();
27791 wxPyEndAllowThreads(__tstate);
27792 if (PyErr_Occurred()) SWIG_fail;
27793 }
27794 resultobj = SWIG_NewPointerObj((new wxLayoutDirection(static_cast< const wxLayoutDirection& >(result))), SWIGTYPE_p_wxLayoutDirection, SWIG_POINTER_OWN | 0 );
27795 return resultobj;
27796 fail:
27797 return NULL;
27798 }
27799
27800
27801 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27802 PyObject *resultobj = 0;
27803 wxPyApp *arg1 = (wxPyApp *) 0 ;
27804 void *argp1 = 0 ;
27805 int res1 = 0 ;
27806 PyObject *swig_obj[1] ;
27807
27808 if (!args) SWIG_fail;
27809 swig_obj[0] = args;
27810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27811 if (!SWIG_IsOK(res1)) {
27812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27813 }
27814 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27815 {
27816 PyThreadState* __tstate = wxPyBeginAllowThreads();
27817 (arg1)->ExitMainLoop();
27818 wxPyEndAllowThreads(__tstate);
27819 if (PyErr_Occurred()) SWIG_fail;
27820 }
27821 resultobj = SWIG_Py_Void();
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27829 PyObject *resultobj = 0;
27830 wxPyApp *arg1 = (wxPyApp *) 0 ;
27831 bool result;
27832 void *argp1 = 0 ;
27833 int res1 = 0 ;
27834 PyObject *swig_obj[1] ;
27835
27836 if (!args) SWIG_fail;
27837 swig_obj[0] = args;
27838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27839 if (!SWIG_IsOK(res1)) {
27840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27841 }
27842 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27843 {
27844 PyThreadState* __tstate = wxPyBeginAllowThreads();
27845 result = (bool)(arg1)->Pending();
27846 wxPyEndAllowThreads(__tstate);
27847 if (PyErr_Occurred()) SWIG_fail;
27848 }
27849 {
27850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27851 }
27852 return resultobj;
27853 fail:
27854 return NULL;
27855 }
27856
27857
27858 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27859 PyObject *resultobj = 0;
27860 wxPyApp *arg1 = (wxPyApp *) 0 ;
27861 bool result;
27862 void *argp1 = 0 ;
27863 int res1 = 0 ;
27864 PyObject *swig_obj[1] ;
27865
27866 if (!args) SWIG_fail;
27867 swig_obj[0] = args;
27868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27869 if (!SWIG_IsOK(res1)) {
27870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27871 }
27872 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27873 {
27874 PyThreadState* __tstate = wxPyBeginAllowThreads();
27875 result = (bool)(arg1)->Dispatch();
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 {
27880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27881 }
27882 return resultobj;
27883 fail:
27884 return NULL;
27885 }
27886
27887
27888 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27889 PyObject *resultobj = 0;
27890 wxPyApp *arg1 = (wxPyApp *) 0 ;
27891 bool result;
27892 void *argp1 = 0 ;
27893 int res1 = 0 ;
27894 PyObject *swig_obj[1] ;
27895
27896 if (!args) SWIG_fail;
27897 swig_obj[0] = args;
27898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27899 if (!SWIG_IsOK(res1)) {
27900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27901 }
27902 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27903 {
27904 PyThreadState* __tstate = wxPyBeginAllowThreads();
27905 result = (bool)(arg1)->ProcessIdle();
27906 wxPyEndAllowThreads(__tstate);
27907 if (PyErr_Occurred()) SWIG_fail;
27908 }
27909 {
27910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27911 }
27912 return resultobj;
27913 fail:
27914 return NULL;
27915 }
27916
27917
27918 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27919 PyObject *resultobj = 0;
27920 wxPyApp *arg1 = (wxPyApp *) 0 ;
27921 wxWindow *arg2 = (wxWindow *) 0 ;
27922 wxIdleEvent *arg3 = 0 ;
27923 bool result;
27924 void *argp1 = 0 ;
27925 int res1 = 0 ;
27926 void *argp2 = 0 ;
27927 int res2 = 0 ;
27928 void *argp3 = 0 ;
27929 int res3 = 0 ;
27930 PyObject * obj0 = 0 ;
27931 PyObject * obj1 = 0 ;
27932 PyObject * obj2 = 0 ;
27933 char * kwnames[] = {
27934 (char *) "self",(char *) "win",(char *) "event", NULL
27935 };
27936
27937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27939 if (!SWIG_IsOK(res1)) {
27940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27941 }
27942 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27943 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27944 if (!SWIG_IsOK(res2)) {
27945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27946 }
27947 arg2 = reinterpret_cast< wxWindow * >(argp2);
27948 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27949 if (!SWIG_IsOK(res3)) {
27950 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27951 }
27952 if (!argp3) {
27953 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27954 }
27955 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27956 {
27957 PyThreadState* __tstate = wxPyBeginAllowThreads();
27958 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27959 wxPyEndAllowThreads(__tstate);
27960 if (PyErr_Occurred()) SWIG_fail;
27961 }
27962 {
27963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27964 }
27965 return resultobj;
27966 fail:
27967 return NULL;
27968 }
27969
27970
27971 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27972 PyObject *resultobj = 0;
27973 wxPyApp *arg1 = (wxPyApp *) 0 ;
27974 bool result;
27975 void *argp1 = 0 ;
27976 int res1 = 0 ;
27977 PyObject *swig_obj[1] ;
27978
27979 if (!args) SWIG_fail;
27980 swig_obj[0] = args;
27981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27982 if (!SWIG_IsOK(res1)) {
27983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27984 }
27985 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27986 {
27987 PyThreadState* __tstate = wxPyBeginAllowThreads();
27988 result = (bool)((wxPyApp const *)arg1)->IsActive();
27989 wxPyEndAllowThreads(__tstate);
27990 if (PyErr_Occurred()) SWIG_fail;
27991 }
27992 {
27993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27994 }
27995 return resultobj;
27996 fail:
27997 return NULL;
27998 }
27999
28000
28001 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28002 PyObject *resultobj = 0;
28003 wxPyApp *arg1 = (wxPyApp *) 0 ;
28004 wxWindow *arg2 = (wxWindow *) 0 ;
28005 void *argp1 = 0 ;
28006 int res1 = 0 ;
28007 void *argp2 = 0 ;
28008 int res2 = 0 ;
28009 PyObject * obj0 = 0 ;
28010 PyObject * obj1 = 0 ;
28011 char * kwnames[] = {
28012 (char *) "self",(char *) "win", NULL
28013 };
28014
28015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28017 if (!SWIG_IsOK(res1)) {
28018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
28019 }
28020 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28021 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28022 if (!SWIG_IsOK(res2)) {
28023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28024 }
28025 arg2 = reinterpret_cast< wxWindow * >(argp2);
28026 {
28027 PyThreadState* __tstate = wxPyBeginAllowThreads();
28028 (arg1)->SetTopWindow(arg2);
28029 wxPyEndAllowThreads(__tstate);
28030 if (PyErr_Occurred()) SWIG_fail;
28031 }
28032 resultobj = SWIG_Py_Void();
28033 return resultobj;
28034 fail:
28035 return NULL;
28036 }
28037
28038
28039 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28040 PyObject *resultobj = 0;
28041 wxPyApp *arg1 = (wxPyApp *) 0 ;
28042 wxWindow *result = 0 ;
28043 void *argp1 = 0 ;
28044 int res1 = 0 ;
28045 PyObject *swig_obj[1] ;
28046
28047 if (!args) SWIG_fail;
28048 swig_obj[0] = args;
28049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28050 if (!SWIG_IsOK(res1)) {
28051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28052 }
28053 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28054 {
28055 PyThreadState* __tstate = wxPyBeginAllowThreads();
28056 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
28057 wxPyEndAllowThreads(__tstate);
28058 if (PyErr_Occurred()) SWIG_fail;
28059 }
28060 {
28061 resultobj = wxPyMake_wxObject(result, (bool)0);
28062 }
28063 return resultobj;
28064 fail:
28065 return NULL;
28066 }
28067
28068
28069 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28070 PyObject *resultobj = 0;
28071 wxPyApp *arg1 = (wxPyApp *) 0 ;
28072 bool arg2 ;
28073 void *argp1 = 0 ;
28074 int res1 = 0 ;
28075 bool val2 ;
28076 int ecode2 = 0 ;
28077 PyObject * obj0 = 0 ;
28078 PyObject * obj1 = 0 ;
28079 char * kwnames[] = {
28080 (char *) "self",(char *) "flag", NULL
28081 };
28082
28083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
28084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28085 if (!SWIG_IsOK(res1)) {
28086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
28087 }
28088 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28089 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28090 if (!SWIG_IsOK(ecode2)) {
28091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
28092 }
28093 arg2 = static_cast< bool >(val2);
28094 {
28095 PyThreadState* __tstate = wxPyBeginAllowThreads();
28096 (arg1)->SetExitOnFrameDelete(arg2);
28097 wxPyEndAllowThreads(__tstate);
28098 if (PyErr_Occurred()) SWIG_fail;
28099 }
28100 resultobj = SWIG_Py_Void();
28101 return resultobj;
28102 fail:
28103 return NULL;
28104 }
28105
28106
28107 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28108 PyObject *resultobj = 0;
28109 wxPyApp *arg1 = (wxPyApp *) 0 ;
28110 bool result;
28111 void *argp1 = 0 ;
28112 int res1 = 0 ;
28113 PyObject *swig_obj[1] ;
28114
28115 if (!args) SWIG_fail;
28116 swig_obj[0] = args;
28117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28118 if (!SWIG_IsOK(res1)) {
28119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28120 }
28121 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28122 {
28123 PyThreadState* __tstate = wxPyBeginAllowThreads();
28124 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 {
28129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28130 }
28131 return resultobj;
28132 fail:
28133 return NULL;
28134 }
28135
28136
28137 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28138 PyObject *resultobj = 0;
28139 wxPyApp *arg1 = (wxPyApp *) 0 ;
28140 bool arg2 ;
28141 void *argp1 = 0 ;
28142 int res1 = 0 ;
28143 bool val2 ;
28144 int ecode2 = 0 ;
28145 PyObject * obj0 = 0 ;
28146 PyObject * obj1 = 0 ;
28147 char * kwnames[] = {
28148 (char *) "self",(char *) "flag", NULL
28149 };
28150
28151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
28152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28153 if (!SWIG_IsOK(res1)) {
28154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
28155 }
28156 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28157 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28158 if (!SWIG_IsOK(ecode2)) {
28159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
28160 }
28161 arg2 = static_cast< bool >(val2);
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 (arg1)->SetUseBestVisual(arg2);
28165 wxPyEndAllowThreads(__tstate);
28166 if (PyErr_Occurred()) SWIG_fail;
28167 }
28168 resultobj = SWIG_Py_Void();
28169 return resultobj;
28170 fail:
28171 return NULL;
28172 }
28173
28174
28175 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28176 PyObject *resultobj = 0;
28177 wxPyApp *arg1 = (wxPyApp *) 0 ;
28178 bool result;
28179 void *argp1 = 0 ;
28180 int res1 = 0 ;
28181 PyObject *swig_obj[1] ;
28182
28183 if (!args) SWIG_fail;
28184 swig_obj[0] = args;
28185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28186 if (!SWIG_IsOK(res1)) {
28187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28188 }
28189 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28190 {
28191 PyThreadState* __tstate = wxPyBeginAllowThreads();
28192 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
28193 wxPyEndAllowThreads(__tstate);
28194 if (PyErr_Occurred()) SWIG_fail;
28195 }
28196 {
28197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28198 }
28199 return resultobj;
28200 fail:
28201 return NULL;
28202 }
28203
28204
28205 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28206 PyObject *resultobj = 0;
28207 wxPyApp *arg1 = (wxPyApp *) 0 ;
28208 int arg2 ;
28209 void *argp1 = 0 ;
28210 int res1 = 0 ;
28211 int val2 ;
28212 int ecode2 = 0 ;
28213 PyObject * obj0 = 0 ;
28214 PyObject * obj1 = 0 ;
28215 char * kwnames[] = {
28216 (char *) "self",(char *) "mode", NULL
28217 };
28218
28219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
28220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28221 if (!SWIG_IsOK(res1)) {
28222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28223 }
28224 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28225 ecode2 = SWIG_AsVal_int(obj1, &val2);
28226 if (!SWIG_IsOK(ecode2)) {
28227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28228 }
28229 arg2 = static_cast< int >(val2);
28230 {
28231 PyThreadState* __tstate = wxPyBeginAllowThreads();
28232 (arg1)->SetPrintMode(arg2);
28233 wxPyEndAllowThreads(__tstate);
28234 if (PyErr_Occurred()) SWIG_fail;
28235 }
28236 resultobj = SWIG_Py_Void();
28237 return resultobj;
28238 fail:
28239 return NULL;
28240 }
28241
28242
28243 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28244 PyObject *resultobj = 0;
28245 wxPyApp *arg1 = (wxPyApp *) 0 ;
28246 int result;
28247 void *argp1 = 0 ;
28248 int res1 = 0 ;
28249 PyObject *swig_obj[1] ;
28250
28251 if (!args) SWIG_fail;
28252 swig_obj[0] = args;
28253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28254 if (!SWIG_IsOK(res1)) {
28255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28256 }
28257 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28258 {
28259 PyThreadState* __tstate = wxPyBeginAllowThreads();
28260 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28261 wxPyEndAllowThreads(__tstate);
28262 if (PyErr_Occurred()) SWIG_fail;
28263 }
28264 resultobj = SWIG_From_int(static_cast< int >(result));
28265 return resultobj;
28266 fail:
28267 return NULL;
28268 }
28269
28270
28271 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28272 PyObject *resultobj = 0;
28273 wxPyApp *arg1 = (wxPyApp *) 0 ;
28274 int arg2 ;
28275 void *argp1 = 0 ;
28276 int res1 = 0 ;
28277 int val2 ;
28278 int ecode2 = 0 ;
28279 PyObject * obj0 = 0 ;
28280 PyObject * obj1 = 0 ;
28281 char * kwnames[] = {
28282 (char *) "self",(char *) "mode", NULL
28283 };
28284
28285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28287 if (!SWIG_IsOK(res1)) {
28288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28289 }
28290 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28291 ecode2 = SWIG_AsVal_int(obj1, &val2);
28292 if (!SWIG_IsOK(ecode2)) {
28293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28294 }
28295 arg2 = static_cast< int >(val2);
28296 {
28297 PyThreadState* __tstate = wxPyBeginAllowThreads();
28298 (arg1)->SetAssertMode(arg2);
28299 wxPyEndAllowThreads(__tstate);
28300 if (PyErr_Occurred()) SWIG_fail;
28301 }
28302 resultobj = SWIG_Py_Void();
28303 return resultobj;
28304 fail:
28305 return NULL;
28306 }
28307
28308
28309 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28310 PyObject *resultobj = 0;
28311 wxPyApp *arg1 = (wxPyApp *) 0 ;
28312 int result;
28313 void *argp1 = 0 ;
28314 int res1 = 0 ;
28315 PyObject *swig_obj[1] ;
28316
28317 if (!args) SWIG_fail;
28318 swig_obj[0] = args;
28319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28320 if (!SWIG_IsOK(res1)) {
28321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28322 }
28323 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28324 {
28325 PyThreadState* __tstate = wxPyBeginAllowThreads();
28326 result = (int)(arg1)->GetAssertMode();
28327 wxPyEndAllowThreads(__tstate);
28328 if (PyErr_Occurred()) SWIG_fail;
28329 }
28330 resultobj = SWIG_From_int(static_cast< int >(result));
28331 return resultobj;
28332 fail:
28333 return NULL;
28334 }
28335
28336
28337 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28338 PyObject *resultobj = 0;
28339 bool result;
28340
28341 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28342 {
28343 PyThreadState* __tstate = wxPyBeginAllowThreads();
28344 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28345 wxPyEndAllowThreads(__tstate);
28346 if (PyErr_Occurred()) SWIG_fail;
28347 }
28348 {
28349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28350 }
28351 return resultobj;
28352 fail:
28353 return NULL;
28354 }
28355
28356
28357 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28358 PyObject *resultobj = 0;
28359 long result;
28360
28361 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28362 {
28363 PyThreadState* __tstate = wxPyBeginAllowThreads();
28364 result = (long)wxPyApp::GetMacAboutMenuItemId();
28365 wxPyEndAllowThreads(__tstate);
28366 if (PyErr_Occurred()) SWIG_fail;
28367 }
28368 resultobj = SWIG_From_long(static_cast< long >(result));
28369 return resultobj;
28370 fail:
28371 return NULL;
28372 }
28373
28374
28375 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28376 PyObject *resultobj = 0;
28377 long result;
28378
28379 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28380 {
28381 PyThreadState* __tstate = wxPyBeginAllowThreads();
28382 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28383 wxPyEndAllowThreads(__tstate);
28384 if (PyErr_Occurred()) SWIG_fail;
28385 }
28386 resultobj = SWIG_From_long(static_cast< long >(result));
28387 return resultobj;
28388 fail:
28389 return NULL;
28390 }
28391
28392
28393 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28394 PyObject *resultobj = 0;
28395 long result;
28396
28397 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28398 {
28399 PyThreadState* __tstate = wxPyBeginAllowThreads();
28400 result = (long)wxPyApp::GetMacExitMenuItemId();
28401 wxPyEndAllowThreads(__tstate);
28402 if (PyErr_Occurred()) SWIG_fail;
28403 }
28404 resultobj = SWIG_From_long(static_cast< long >(result));
28405 return resultobj;
28406 fail:
28407 return NULL;
28408 }
28409
28410
28411 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28412 PyObject *resultobj = 0;
28413 wxString result;
28414
28415 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28416 {
28417 PyThreadState* __tstate = wxPyBeginAllowThreads();
28418 result = wxPyApp::GetMacHelpMenuTitleName();
28419 wxPyEndAllowThreads(__tstate);
28420 if (PyErr_Occurred()) SWIG_fail;
28421 }
28422 {
28423 #if wxUSE_UNICODE
28424 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28425 #else
28426 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28427 #endif
28428 }
28429 return resultobj;
28430 fail:
28431 return NULL;
28432 }
28433
28434
28435 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28436 PyObject *resultobj = 0;
28437 bool arg1 ;
28438 bool val1 ;
28439 int ecode1 = 0 ;
28440 PyObject * obj0 = 0 ;
28441 char * kwnames[] = {
28442 (char *) "val", NULL
28443 };
28444
28445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28446 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28447 if (!SWIG_IsOK(ecode1)) {
28448 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28449 }
28450 arg1 = static_cast< bool >(val1);
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28454 wxPyEndAllowThreads(__tstate);
28455 if (PyErr_Occurred()) SWIG_fail;
28456 }
28457 resultobj = SWIG_Py_Void();
28458 return resultobj;
28459 fail:
28460 return NULL;
28461 }
28462
28463
28464 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28465 PyObject *resultobj = 0;
28466 long arg1 ;
28467 long val1 ;
28468 int ecode1 = 0 ;
28469 PyObject * obj0 = 0 ;
28470 char * kwnames[] = {
28471 (char *) "val", NULL
28472 };
28473
28474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28475 ecode1 = SWIG_AsVal_long(obj0, &val1);
28476 if (!SWIG_IsOK(ecode1)) {
28477 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28478 }
28479 arg1 = static_cast< long >(val1);
28480 {
28481 PyThreadState* __tstate = wxPyBeginAllowThreads();
28482 wxPyApp::SetMacAboutMenuItemId(arg1);
28483 wxPyEndAllowThreads(__tstate);
28484 if (PyErr_Occurred()) SWIG_fail;
28485 }
28486 resultobj = SWIG_Py_Void();
28487 return resultobj;
28488 fail:
28489 return NULL;
28490 }
28491
28492
28493 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28494 PyObject *resultobj = 0;
28495 long arg1 ;
28496 long val1 ;
28497 int ecode1 = 0 ;
28498 PyObject * obj0 = 0 ;
28499 char * kwnames[] = {
28500 (char *) "val", NULL
28501 };
28502
28503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28504 ecode1 = SWIG_AsVal_long(obj0, &val1);
28505 if (!SWIG_IsOK(ecode1)) {
28506 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28507 }
28508 arg1 = static_cast< long >(val1);
28509 {
28510 PyThreadState* __tstate = wxPyBeginAllowThreads();
28511 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28512 wxPyEndAllowThreads(__tstate);
28513 if (PyErr_Occurred()) SWIG_fail;
28514 }
28515 resultobj = SWIG_Py_Void();
28516 return resultobj;
28517 fail:
28518 return NULL;
28519 }
28520
28521
28522 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28523 PyObject *resultobj = 0;
28524 long arg1 ;
28525 long val1 ;
28526 int ecode1 = 0 ;
28527 PyObject * obj0 = 0 ;
28528 char * kwnames[] = {
28529 (char *) "val", NULL
28530 };
28531
28532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28533 ecode1 = SWIG_AsVal_long(obj0, &val1);
28534 if (!SWIG_IsOK(ecode1)) {
28535 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28536 }
28537 arg1 = static_cast< long >(val1);
28538 {
28539 PyThreadState* __tstate = wxPyBeginAllowThreads();
28540 wxPyApp::SetMacExitMenuItemId(arg1);
28541 wxPyEndAllowThreads(__tstate);
28542 if (PyErr_Occurred()) SWIG_fail;
28543 }
28544 resultobj = SWIG_Py_Void();
28545 return resultobj;
28546 fail:
28547 return NULL;
28548 }
28549
28550
28551 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28552 PyObject *resultobj = 0;
28553 wxString *arg1 = 0 ;
28554 bool temp1 = false ;
28555 PyObject * obj0 = 0 ;
28556 char * kwnames[] = {
28557 (char *) "val", NULL
28558 };
28559
28560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28561 {
28562 arg1 = wxString_in_helper(obj0);
28563 if (arg1 == NULL) SWIG_fail;
28564 temp1 = true;
28565 }
28566 {
28567 PyThreadState* __tstate = wxPyBeginAllowThreads();
28568 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28569 wxPyEndAllowThreads(__tstate);
28570 if (PyErr_Occurred()) SWIG_fail;
28571 }
28572 resultobj = SWIG_Py_Void();
28573 {
28574 if (temp1)
28575 delete arg1;
28576 }
28577 return resultobj;
28578 fail:
28579 {
28580 if (temp1)
28581 delete arg1;
28582 }
28583 return NULL;
28584 }
28585
28586
28587 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28588 PyObject *resultobj = 0;
28589 wxPyApp *arg1 = (wxPyApp *) 0 ;
28590 void *argp1 = 0 ;
28591 int res1 = 0 ;
28592 PyObject *swig_obj[1] ;
28593
28594 if (!args) SWIG_fail;
28595 swig_obj[0] = args;
28596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28597 if (!SWIG_IsOK(res1)) {
28598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28599 }
28600 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28601 {
28602 PyThreadState* __tstate = wxPyBeginAllowThreads();
28603 (arg1)->_BootstrapApp();
28604 wxPyEndAllowThreads(__tstate);
28605 if (PyErr_Occurred()) SWIG_fail;
28606 }
28607 resultobj = SWIG_Py_Void();
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28615 PyObject *resultobj = 0;
28616 int result;
28617
28618 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28619 {
28620 PyThreadState* __tstate = wxPyBeginAllowThreads();
28621 result = (int)wxPyApp_GetComCtl32Version();
28622 wxPyEndAllowThreads(__tstate);
28623 if (PyErr_Occurred()) SWIG_fail;
28624 }
28625 resultobj = SWIG_From_int(static_cast< int >(result));
28626 return resultobj;
28627 fail:
28628 return NULL;
28629 }
28630
28631
28632 SWIGINTERN PyObject *_wrap_PyApp_DisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28633 PyObject *resultobj = 0;
28634 bool result;
28635
28636 if (!SWIG_Python_UnpackTuple(args,"PyApp_DisplayAvailable",0,0,0)) SWIG_fail;
28637 {
28638 PyThreadState* __tstate = wxPyBeginAllowThreads();
28639 result = (bool)wxPyApp_DisplayAvailable();
28640 wxPyEndAllowThreads(__tstate);
28641 if (PyErr_Occurred()) SWIG_fail;
28642 }
28643 {
28644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28645 }
28646 return resultobj;
28647 fail:
28648 return NULL;
28649 }
28650
28651
28652 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28653 PyObject *obj;
28654 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28655 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28656 return SWIG_Py_Void();
28657 }
28658
28659 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28660 return SWIG_Python_InitShadowInstance(args);
28661 }
28662
28663 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28664 PyObject *resultobj = 0;
28665
28666 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28667 {
28668 PyThreadState* __tstate = wxPyBeginAllowThreads();
28669 wxExit();
28670 wxPyEndAllowThreads(__tstate);
28671 if (PyErr_Occurred()) SWIG_fail;
28672 }
28673 resultobj = SWIG_Py_Void();
28674 return resultobj;
28675 fail:
28676 return NULL;
28677 }
28678
28679
28680 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28681 PyObject *resultobj = 0;
28682 bool result;
28683
28684 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 result = (bool)wxYield();
28688 wxPyEndAllowThreads(__tstate);
28689 if (PyErr_Occurred()) SWIG_fail;
28690 }
28691 {
28692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28693 }
28694 return resultobj;
28695 fail:
28696 return NULL;
28697 }
28698
28699
28700 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28701 PyObject *resultobj = 0;
28702 bool result;
28703
28704 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28705 {
28706 PyThreadState* __tstate = wxPyBeginAllowThreads();
28707 result = (bool)wxYieldIfNeeded();
28708 wxPyEndAllowThreads(__tstate);
28709 if (PyErr_Occurred()) SWIG_fail;
28710 }
28711 {
28712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28713 }
28714 return resultobj;
28715 fail:
28716 return NULL;
28717 }
28718
28719
28720 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28721 PyObject *resultobj = 0;
28722 wxWindow *arg1 = (wxWindow *) NULL ;
28723 bool arg2 = (bool) false ;
28724 bool result;
28725 void *argp1 = 0 ;
28726 int res1 = 0 ;
28727 bool val2 ;
28728 int ecode2 = 0 ;
28729 PyObject * obj0 = 0 ;
28730 PyObject * obj1 = 0 ;
28731 char * kwnames[] = {
28732 (char *) "win",(char *) "onlyIfNeeded", NULL
28733 };
28734
28735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28736 if (obj0) {
28737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28738 if (!SWIG_IsOK(res1)) {
28739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28740 }
28741 arg1 = reinterpret_cast< wxWindow * >(argp1);
28742 }
28743 if (obj1) {
28744 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28745 if (!SWIG_IsOK(ecode2)) {
28746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28747 }
28748 arg2 = static_cast< bool >(val2);
28749 }
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 result = (bool)wxSafeYield(arg1,arg2);
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 {
28757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28758 }
28759 return resultobj;
28760 fail:
28761 return NULL;
28762 }
28763
28764
28765 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28766 PyObject *resultobj = 0;
28767
28768 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28769 {
28770 PyThreadState* __tstate = wxPyBeginAllowThreads();
28771 wxWakeUpIdle();
28772 wxPyEndAllowThreads(__tstate);
28773 if (PyErr_Occurred()) SWIG_fail;
28774 }
28775 resultobj = SWIG_Py_Void();
28776 return resultobj;
28777 fail:
28778 return NULL;
28779 }
28780
28781
28782 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28783 PyObject *resultobj = 0;
28784 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28785 wxEvent *arg2 = 0 ;
28786 void *argp1 = 0 ;
28787 int res1 = 0 ;
28788 void *argp2 = 0 ;
28789 int res2 = 0 ;
28790 PyObject * obj0 = 0 ;
28791 PyObject * obj1 = 0 ;
28792 char * kwnames[] = {
28793 (char *) "dest",(char *) "event", NULL
28794 };
28795
28796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28798 if (!SWIG_IsOK(res1)) {
28799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28800 }
28801 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28802 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28803 if (!SWIG_IsOK(res2)) {
28804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28805 }
28806 if (!argp2) {
28807 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28808 }
28809 arg2 = reinterpret_cast< wxEvent * >(argp2);
28810 {
28811 PyThreadState* __tstate = wxPyBeginAllowThreads();
28812 wxPostEvent(arg1,*arg2);
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_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28824 PyObject *resultobj = 0;
28825
28826 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28827 {
28828 PyThreadState* __tstate = wxPyBeginAllowThreads();
28829 wxApp_CleanUp();
28830 wxPyEndAllowThreads(__tstate);
28831 if (PyErr_Occurred()) SWIG_fail;
28832 }
28833 resultobj = SWIG_Py_Void();
28834 return resultobj;
28835 fail:
28836 return NULL;
28837 }
28838
28839
28840 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28841 PyObject *resultobj = 0;
28842 wxPyApp *result = 0 ;
28843
28844 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28845 {
28846 PyThreadState* __tstate = wxPyBeginAllowThreads();
28847 result = (wxPyApp *)wxPyGetApp();
28848 wxPyEndAllowThreads(__tstate);
28849 if (PyErr_Occurred()) SWIG_fail;
28850 }
28851 {
28852 resultobj = wxPyMake_wxObject(result, 0);
28853 }
28854 return resultobj;
28855 fail:
28856 return NULL;
28857 }
28858
28859
28860 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28861 PyObject *resultobj = 0;
28862 char *arg1 = (char *) 0 ;
28863 int res1 ;
28864 char *buf1 = 0 ;
28865 int alloc1 = 0 ;
28866 PyObject * obj0 = 0 ;
28867 char * kwnames[] = {
28868 (char *) "encoding", NULL
28869 };
28870
28871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28872 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28873 if (!SWIG_IsOK(res1)) {
28874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28875 }
28876 arg1 = buf1;
28877 {
28878 PyThreadState* __tstate = wxPyBeginAllowThreads();
28879 wxSetDefaultPyEncoding((char const *)arg1);
28880 wxPyEndAllowThreads(__tstate);
28881 if (PyErr_Occurred()) SWIG_fail;
28882 }
28883 resultobj = SWIG_Py_Void();
28884 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28885 return resultobj;
28886 fail:
28887 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28888 return NULL;
28889 }
28890
28891
28892 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28893 PyObject *resultobj = 0;
28894 char *result = 0 ;
28895
28896 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28897 {
28898 PyThreadState* __tstate = wxPyBeginAllowThreads();
28899 result = (char *)wxGetDefaultPyEncoding();
28900 wxPyEndAllowThreads(__tstate);
28901 if (PyErr_Occurred()) SWIG_fail;
28902 }
28903 resultobj = SWIG_FromCharPtr(result);
28904 return resultobj;
28905 fail:
28906 return NULL;
28907 }
28908
28909
28910 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28911 PyObject *resultobj = 0;
28912 wxEventLoop *result = 0 ;
28913
28914 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28915 {
28916 PyThreadState* __tstate = wxPyBeginAllowThreads();
28917 result = (wxEventLoop *)new wxEventLoop();
28918 wxPyEndAllowThreads(__tstate);
28919 if (PyErr_Occurred()) SWIG_fail;
28920 }
28921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28922 return resultobj;
28923 fail:
28924 return NULL;
28925 }
28926
28927
28928 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28929 PyObject *resultobj = 0;
28930 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28931 void *argp1 = 0 ;
28932 int res1 = 0 ;
28933 PyObject *swig_obj[1] ;
28934
28935 if (!args) SWIG_fail;
28936 swig_obj[0] = args;
28937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28938 if (!SWIG_IsOK(res1)) {
28939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28940 }
28941 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28942 {
28943 PyThreadState* __tstate = wxPyBeginAllowThreads();
28944 delete arg1;
28945
28946 wxPyEndAllowThreads(__tstate);
28947 if (PyErr_Occurred()) SWIG_fail;
28948 }
28949 resultobj = SWIG_Py_Void();
28950 return resultobj;
28951 fail:
28952 return NULL;
28953 }
28954
28955
28956 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28957 PyObject *resultobj = 0;
28958 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28959 int result;
28960 void *argp1 = 0 ;
28961 int res1 = 0 ;
28962 PyObject *swig_obj[1] ;
28963
28964 if (!args) SWIG_fail;
28965 swig_obj[0] = args;
28966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28967 if (!SWIG_IsOK(res1)) {
28968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28969 }
28970 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28971 {
28972 PyThreadState* __tstate = wxPyBeginAllowThreads();
28973 result = (int)(arg1)->Run();
28974 wxPyEndAllowThreads(__tstate);
28975 if (PyErr_Occurred()) SWIG_fail;
28976 }
28977 resultobj = SWIG_From_int(static_cast< int >(result));
28978 return resultobj;
28979 fail:
28980 return NULL;
28981 }
28982
28983
28984 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28985 PyObject *resultobj = 0;
28986 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28987 int arg2 = (int) 0 ;
28988 void *argp1 = 0 ;
28989 int res1 = 0 ;
28990 int val2 ;
28991 int ecode2 = 0 ;
28992 PyObject * obj0 = 0 ;
28993 PyObject * obj1 = 0 ;
28994 char * kwnames[] = {
28995 (char *) "self",(char *) "rc", NULL
28996 };
28997
28998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29000 if (!SWIG_IsOK(res1)) {
29001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29002 }
29003 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29004 if (obj1) {
29005 ecode2 = SWIG_AsVal_int(obj1, &val2);
29006 if (!SWIG_IsOK(ecode2)) {
29007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
29008 }
29009 arg2 = static_cast< int >(val2);
29010 }
29011 {
29012 PyThreadState* __tstate = wxPyBeginAllowThreads();
29013 (arg1)->Exit(arg2);
29014 wxPyEndAllowThreads(__tstate);
29015 if (PyErr_Occurred()) SWIG_fail;
29016 }
29017 resultobj = SWIG_Py_Void();
29018 return resultobj;
29019 fail:
29020 return NULL;
29021 }
29022
29023
29024 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29025 PyObject *resultobj = 0;
29026 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29027 bool result;
29028 void *argp1 = 0 ;
29029 int res1 = 0 ;
29030 PyObject *swig_obj[1] ;
29031
29032 if (!args) SWIG_fail;
29033 swig_obj[0] = args;
29034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29035 if (!SWIG_IsOK(res1)) {
29036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29037 }
29038 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29039 {
29040 PyThreadState* __tstate = wxPyBeginAllowThreads();
29041 result = (bool)((wxEventLoop const *)arg1)->Pending();
29042 wxPyEndAllowThreads(__tstate);
29043 if (PyErr_Occurred()) SWIG_fail;
29044 }
29045 {
29046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29047 }
29048 return resultobj;
29049 fail:
29050 return NULL;
29051 }
29052
29053
29054 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29055 PyObject *resultobj = 0;
29056 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29057 bool result;
29058 void *argp1 = 0 ;
29059 int res1 = 0 ;
29060 PyObject *swig_obj[1] ;
29061
29062 if (!args) SWIG_fail;
29063 swig_obj[0] = args;
29064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29065 if (!SWIG_IsOK(res1)) {
29066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29067 }
29068 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29069 {
29070 PyThreadState* __tstate = wxPyBeginAllowThreads();
29071 result = (bool)(arg1)->Dispatch();
29072 wxPyEndAllowThreads(__tstate);
29073 if (PyErr_Occurred()) SWIG_fail;
29074 }
29075 {
29076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29077 }
29078 return resultobj;
29079 fail:
29080 return NULL;
29081 }
29082
29083
29084 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29085 PyObject *resultobj = 0;
29086 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29087 bool result;
29088 void *argp1 = 0 ;
29089 int res1 = 0 ;
29090 PyObject *swig_obj[1] ;
29091
29092 if (!args) SWIG_fail;
29093 swig_obj[0] = args;
29094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29095 if (!SWIG_IsOK(res1)) {
29096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
29097 }
29098 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29099 {
29100 PyThreadState* __tstate = wxPyBeginAllowThreads();
29101 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
29102 wxPyEndAllowThreads(__tstate);
29103 if (PyErr_Occurred()) SWIG_fail;
29104 }
29105 {
29106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29107 }
29108 return resultobj;
29109 fail:
29110 return NULL;
29111 }
29112
29113
29114 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29115 PyObject *resultobj = 0;
29116 wxEventLoop *result = 0 ;
29117
29118 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
29119 {
29120 PyThreadState* __tstate = wxPyBeginAllowThreads();
29121 result = (wxEventLoop *)wxEventLoop::GetActive();
29122 wxPyEndAllowThreads(__tstate);
29123 if (PyErr_Occurred()) SWIG_fail;
29124 }
29125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
29126 return resultobj;
29127 fail:
29128 return NULL;
29129 }
29130
29131
29132 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29133 PyObject *resultobj = 0;
29134 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29135 void *argp1 = 0 ;
29136 int res1 = 0 ;
29137 PyObject * obj0 = 0 ;
29138 char * kwnames[] = {
29139 (char *) "loop", NULL
29140 };
29141
29142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
29143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29144 if (!SWIG_IsOK(res1)) {
29145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29146 }
29147 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29148 {
29149 PyThreadState* __tstate = wxPyBeginAllowThreads();
29150 wxEventLoop::SetActive(arg1);
29151 wxPyEndAllowThreads(__tstate);
29152 if (PyErr_Occurred()) SWIG_fail;
29153 }
29154 resultobj = SWIG_Py_Void();
29155 return resultobj;
29156 fail:
29157 return NULL;
29158 }
29159
29160
29161 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29162 PyObject *obj;
29163 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29164 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
29165 return SWIG_Py_Void();
29166 }
29167
29168 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29169 return SWIG_Python_InitShadowInstance(args);
29170 }
29171
29172 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29173 PyObject *resultobj = 0;
29174 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
29175 wxEventLoopActivator *result = 0 ;
29176 void *argp1 = 0 ;
29177 int res1 = 0 ;
29178 PyObject * obj0 = 0 ;
29179 char * kwnames[] = {
29180 (char *) "evtLoop", NULL
29181 };
29182
29183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
29184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
29185 if (!SWIG_IsOK(res1)) {
29186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
29187 }
29188 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
29189 {
29190 PyThreadState* __tstate = wxPyBeginAllowThreads();
29191 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
29192 wxPyEndAllowThreads(__tstate);
29193 if (PyErr_Occurred()) SWIG_fail;
29194 }
29195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
29196 return resultobj;
29197 fail:
29198 return NULL;
29199 }
29200
29201
29202 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29203 PyObject *resultobj = 0;
29204 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
29205 void *argp1 = 0 ;
29206 int res1 = 0 ;
29207 PyObject *swig_obj[1] ;
29208
29209 if (!args) SWIG_fail;
29210 swig_obj[0] = args;
29211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
29212 if (!SWIG_IsOK(res1)) {
29213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
29214 }
29215 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
29216 {
29217 PyThreadState* __tstate = wxPyBeginAllowThreads();
29218 delete arg1;
29219
29220 wxPyEndAllowThreads(__tstate);
29221 if (PyErr_Occurred()) SWIG_fail;
29222 }
29223 resultobj = SWIG_Py_Void();
29224 return resultobj;
29225 fail:
29226 return NULL;
29227 }
29228
29229
29230 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29231 PyObject *obj;
29232 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29233 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
29234 return SWIG_Py_Void();
29235 }
29236
29237 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29238 return SWIG_Python_InitShadowInstance(args);
29239 }
29240
29241 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29242 PyObject *resultobj = 0;
29243 int arg1 = (int) 0 ;
29244 int arg2 = (int) 0 ;
29245 int arg3 = (int) 0 ;
29246 wxAcceleratorEntry *result = 0 ;
29247 int val1 ;
29248 int ecode1 = 0 ;
29249 int val2 ;
29250 int ecode2 = 0 ;
29251 int val3 ;
29252 int ecode3 = 0 ;
29253 PyObject * obj0 = 0 ;
29254 PyObject * obj1 = 0 ;
29255 PyObject * obj2 = 0 ;
29256 char * kwnames[] = {
29257 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29258 };
29259
29260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29261 if (obj0) {
29262 ecode1 = SWIG_AsVal_int(obj0, &val1);
29263 if (!SWIG_IsOK(ecode1)) {
29264 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29265 }
29266 arg1 = static_cast< int >(val1);
29267 }
29268 if (obj1) {
29269 ecode2 = SWIG_AsVal_int(obj1, &val2);
29270 if (!SWIG_IsOK(ecode2)) {
29271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29272 }
29273 arg2 = static_cast< int >(val2);
29274 }
29275 if (obj2) {
29276 ecode3 = SWIG_AsVal_int(obj2, &val3);
29277 if (!SWIG_IsOK(ecode3)) {
29278 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29279 }
29280 arg3 = static_cast< int >(val3);
29281 }
29282 {
29283 PyThreadState* __tstate = wxPyBeginAllowThreads();
29284 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29285 wxPyEndAllowThreads(__tstate);
29286 if (PyErr_Occurred()) SWIG_fail;
29287 }
29288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29289 return resultobj;
29290 fail:
29291 return NULL;
29292 }
29293
29294
29295 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29296 PyObject *resultobj = 0;
29297 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29298 void *argp1 = 0 ;
29299 int res1 = 0 ;
29300 PyObject *swig_obj[1] ;
29301
29302 if (!args) SWIG_fail;
29303 swig_obj[0] = args;
29304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29305 if (!SWIG_IsOK(res1)) {
29306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29307 }
29308 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29309 {
29310 PyThreadState* __tstate = wxPyBeginAllowThreads();
29311 delete arg1;
29312
29313 wxPyEndAllowThreads(__tstate);
29314 if (PyErr_Occurred()) SWIG_fail;
29315 }
29316 resultobj = SWIG_Py_Void();
29317 return resultobj;
29318 fail:
29319 return NULL;
29320 }
29321
29322
29323 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29324 PyObject *resultobj = 0;
29325 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29326 int arg2 ;
29327 int arg3 ;
29328 int arg4 ;
29329 void *argp1 = 0 ;
29330 int res1 = 0 ;
29331 int val2 ;
29332 int ecode2 = 0 ;
29333 int val3 ;
29334 int ecode3 = 0 ;
29335 int val4 ;
29336 int ecode4 = 0 ;
29337 PyObject * obj0 = 0 ;
29338 PyObject * obj1 = 0 ;
29339 PyObject * obj2 = 0 ;
29340 PyObject * obj3 = 0 ;
29341 char * kwnames[] = {
29342 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29343 };
29344
29345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29347 if (!SWIG_IsOK(res1)) {
29348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29349 }
29350 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29351 ecode2 = SWIG_AsVal_int(obj1, &val2);
29352 if (!SWIG_IsOK(ecode2)) {
29353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29354 }
29355 arg2 = static_cast< int >(val2);
29356 ecode3 = SWIG_AsVal_int(obj2, &val3);
29357 if (!SWIG_IsOK(ecode3)) {
29358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29359 }
29360 arg3 = static_cast< int >(val3);
29361 ecode4 = SWIG_AsVal_int(obj3, &val4);
29362 if (!SWIG_IsOK(ecode4)) {
29363 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29364 }
29365 arg4 = static_cast< int >(val4);
29366 {
29367 PyThreadState* __tstate = wxPyBeginAllowThreads();
29368 (arg1)->Set(arg2,arg3,arg4);
29369 wxPyEndAllowThreads(__tstate);
29370 if (PyErr_Occurred()) SWIG_fail;
29371 }
29372 resultobj = SWIG_Py_Void();
29373 return resultobj;
29374 fail:
29375 return NULL;
29376 }
29377
29378
29379 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29380 PyObject *resultobj = 0;
29381 wxString *arg1 = 0 ;
29382 wxAcceleratorEntry *result = 0 ;
29383 bool temp1 = false ;
29384 PyObject * obj0 = 0 ;
29385 char * kwnames[] = {
29386 (char *) "str", NULL
29387 };
29388
29389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
29390 {
29391 arg1 = wxString_in_helper(obj0);
29392 if (arg1 == NULL) SWIG_fail;
29393 temp1 = true;
29394 }
29395 {
29396 PyThreadState* __tstate = wxPyBeginAllowThreads();
29397 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
29398 wxPyEndAllowThreads(__tstate);
29399 if (PyErr_Occurred()) SWIG_fail;
29400 }
29401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
29402 {
29403 if (temp1)
29404 delete arg1;
29405 }
29406 return resultobj;
29407 fail:
29408 {
29409 if (temp1)
29410 delete arg1;
29411 }
29412 return NULL;
29413 }
29414
29415
29416 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29417 PyObject *resultobj = 0;
29418 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29419 int result;
29420 void *argp1 = 0 ;
29421 int res1 = 0 ;
29422 PyObject *swig_obj[1] ;
29423
29424 if (!args) SWIG_fail;
29425 swig_obj[0] = args;
29426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29427 if (!SWIG_IsOK(res1)) {
29428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29429 }
29430 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29431 {
29432 PyThreadState* __tstate = wxPyBeginAllowThreads();
29433 result = (int)(arg1)->GetFlags();
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 resultobj = SWIG_From_int(static_cast< int >(result));
29438 return resultobj;
29439 fail:
29440 return NULL;
29441 }
29442
29443
29444 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29445 PyObject *resultobj = 0;
29446 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29447 int result;
29448 void *argp1 = 0 ;
29449 int res1 = 0 ;
29450 PyObject *swig_obj[1] ;
29451
29452 if (!args) SWIG_fail;
29453 swig_obj[0] = args;
29454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29455 if (!SWIG_IsOK(res1)) {
29456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29457 }
29458 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29459 {
29460 PyThreadState* __tstate = wxPyBeginAllowThreads();
29461 result = (int)(arg1)->GetKeyCode();
29462 wxPyEndAllowThreads(__tstate);
29463 if (PyErr_Occurred()) SWIG_fail;
29464 }
29465 resultobj = SWIG_From_int(static_cast< int >(result));
29466 return resultobj;
29467 fail:
29468 return NULL;
29469 }
29470
29471
29472 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29473 PyObject *resultobj = 0;
29474 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29475 int result;
29476 void *argp1 = 0 ;
29477 int res1 = 0 ;
29478 PyObject *swig_obj[1] ;
29479
29480 if (!args) SWIG_fail;
29481 swig_obj[0] = args;
29482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29483 if (!SWIG_IsOK(res1)) {
29484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29485 }
29486 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29487 {
29488 PyThreadState* __tstate = wxPyBeginAllowThreads();
29489 result = (int)(arg1)->GetCommand();
29490 wxPyEndAllowThreads(__tstate);
29491 if (PyErr_Occurred()) SWIG_fail;
29492 }
29493 resultobj = SWIG_From_int(static_cast< int >(result));
29494 return resultobj;
29495 fail:
29496 return NULL;
29497 }
29498
29499
29500 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29501 PyObject *resultobj = 0;
29502 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29503 bool result;
29504 void *argp1 = 0 ;
29505 int res1 = 0 ;
29506 PyObject *swig_obj[1] ;
29507
29508 if (!args) SWIG_fail;
29509 swig_obj[0] = args;
29510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29511 if (!SWIG_IsOK(res1)) {
29512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29513 }
29514 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29515 {
29516 PyThreadState* __tstate = wxPyBeginAllowThreads();
29517 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
29518 wxPyEndAllowThreads(__tstate);
29519 if (PyErr_Occurred()) SWIG_fail;
29520 }
29521 {
29522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29523 }
29524 return resultobj;
29525 fail:
29526 return NULL;
29527 }
29528
29529
29530 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29531 PyObject *resultobj = 0;
29532 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29533 wxString result;
29534 void *argp1 = 0 ;
29535 int res1 = 0 ;
29536 PyObject *swig_obj[1] ;
29537
29538 if (!args) SWIG_fail;
29539 swig_obj[0] = args;
29540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29541 if (!SWIG_IsOK(res1)) {
29542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
29543 }
29544 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29545 {
29546 PyThreadState* __tstate = wxPyBeginAllowThreads();
29547 result = ((wxAcceleratorEntry const *)arg1)->ToString();
29548 wxPyEndAllowThreads(__tstate);
29549 if (PyErr_Occurred()) SWIG_fail;
29550 }
29551 {
29552 #if wxUSE_UNICODE
29553 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29554 #else
29555 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29556 #endif
29557 }
29558 return resultobj;
29559 fail:
29560 return NULL;
29561 }
29562
29563
29564 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29565 PyObject *resultobj = 0;
29566 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29567 wxString *arg2 = 0 ;
29568 bool result;
29569 void *argp1 = 0 ;
29570 int res1 = 0 ;
29571 bool temp2 = false ;
29572 PyObject * obj0 = 0 ;
29573 PyObject * obj1 = 0 ;
29574 char * kwnames[] = {
29575 (char *) "self",(char *) "str", NULL
29576 };
29577
29578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
29579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29580 if (!SWIG_IsOK(res1)) {
29581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29582 }
29583 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29584 {
29585 arg2 = wxString_in_helper(obj1);
29586 if (arg2 == NULL) SWIG_fail;
29587 temp2 = true;
29588 }
29589 {
29590 PyThreadState* __tstate = wxPyBeginAllowThreads();
29591 result = (bool)(arg1)->FromString((wxString const &)*arg2);
29592 wxPyEndAllowThreads(__tstate);
29593 if (PyErr_Occurred()) SWIG_fail;
29594 }
29595 {
29596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29597 }
29598 {
29599 if (temp2)
29600 delete arg2;
29601 }
29602 return resultobj;
29603 fail:
29604 {
29605 if (temp2)
29606 delete arg2;
29607 }
29608 return NULL;
29609 }
29610
29611
29612 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29613 PyObject *obj;
29614 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29615 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29616 return SWIG_Py_Void();
29617 }
29618
29619 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29620 return SWIG_Python_InitShadowInstance(args);
29621 }
29622
29623 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29624 PyObject *resultobj = 0;
29625 int arg1 ;
29626 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29627 wxAcceleratorTable *result = 0 ;
29628 PyObject * obj0 = 0 ;
29629 char * kwnames[] = {
29630 (char *) "n", NULL
29631 };
29632
29633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29634 {
29635 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29636 if (arg2) arg1 = PyList_Size(obj0);
29637 else arg1 = 0;
29638 }
29639 {
29640 PyThreadState* __tstate = wxPyBeginAllowThreads();
29641 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29642 wxPyEndAllowThreads(__tstate);
29643 if (PyErr_Occurred()) SWIG_fail;
29644 }
29645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29646 return resultobj;
29647 fail:
29648 return NULL;
29649 }
29650
29651
29652 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29653 PyObject *resultobj = 0;
29654 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29655 void *argp1 = 0 ;
29656 int res1 = 0 ;
29657 PyObject *swig_obj[1] ;
29658
29659 if (!args) SWIG_fail;
29660 swig_obj[0] = args;
29661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29662 if (!SWIG_IsOK(res1)) {
29663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29664 }
29665 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29666 {
29667 PyThreadState* __tstate = wxPyBeginAllowThreads();
29668 delete arg1;
29669
29670 wxPyEndAllowThreads(__tstate);
29671 if (PyErr_Occurred()) SWIG_fail;
29672 }
29673 resultobj = SWIG_Py_Void();
29674 return resultobj;
29675 fail:
29676 return NULL;
29677 }
29678
29679
29680 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29681 PyObject *resultobj = 0;
29682 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29683 bool result;
29684 void *argp1 = 0 ;
29685 int res1 = 0 ;
29686 PyObject *swig_obj[1] ;
29687
29688 if (!args) SWIG_fail;
29689 swig_obj[0] = args;
29690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29691 if (!SWIG_IsOK(res1)) {
29692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29693 }
29694 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29695 {
29696 PyThreadState* __tstate = wxPyBeginAllowThreads();
29697 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29698 wxPyEndAllowThreads(__tstate);
29699 if (PyErr_Occurred()) SWIG_fail;
29700 }
29701 {
29702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29703 }
29704 return resultobj;
29705 fail:
29706 return NULL;
29707 }
29708
29709
29710 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29711 PyObject *obj;
29712 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29713 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29714 return SWIG_Py_Void();
29715 }
29716
29717 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29718 return SWIG_Python_InitShadowInstance(args);
29719 }
29720
29721 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29722 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29723 return 1;
29724 }
29725
29726
29727 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29728 PyObject *pyobj = 0;
29729
29730 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29731 return pyobj;
29732 }
29733
29734
29735 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29736 PyObject *resultobj = 0;
29737 wxString *arg1 = 0 ;
29738 wxAcceleratorEntry *result = 0 ;
29739 bool temp1 = false ;
29740 PyObject * obj0 = 0 ;
29741 char * kwnames[] = {
29742 (char *) "label", NULL
29743 };
29744
29745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29746 {
29747 arg1 = wxString_in_helper(obj0);
29748 if (arg1 == NULL) SWIG_fail;
29749 temp1 = true;
29750 }
29751 {
29752 PyThreadState* __tstate = wxPyBeginAllowThreads();
29753 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29754 wxPyEndAllowThreads(__tstate);
29755 if (PyErr_Occurred()) SWIG_fail;
29756 }
29757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29758 {
29759 if (temp1)
29760 delete arg1;
29761 }
29762 return resultobj;
29763 fail:
29764 {
29765 if (temp1)
29766 delete arg1;
29767 }
29768 return NULL;
29769 }
29770
29771
29772 SWIGINTERN int PanelNameStr_set(PyObject *) {
29773 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29774 return 1;
29775 }
29776
29777
29778 SWIGINTERN PyObject *PanelNameStr_get(void) {
29779 PyObject *pyobj = 0;
29780
29781 {
29782 #if wxUSE_UNICODE
29783 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29784 #else
29785 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29786 #endif
29787 }
29788 return pyobj;
29789 }
29790
29791
29792 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29793 PyObject *resultobj = 0;
29794 wxVisualAttributes *result = 0 ;
29795
29796 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29797 {
29798 PyThreadState* __tstate = wxPyBeginAllowThreads();
29799 result = (wxVisualAttributes *)new_wxVisualAttributes();
29800 wxPyEndAllowThreads(__tstate);
29801 if (PyErr_Occurred()) SWIG_fail;
29802 }
29803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29804 return resultobj;
29805 fail:
29806 return NULL;
29807 }
29808
29809
29810 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29811 PyObject *resultobj = 0;
29812 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29813 void *argp1 = 0 ;
29814 int res1 = 0 ;
29815 PyObject *swig_obj[1] ;
29816
29817 if (!args) SWIG_fail;
29818 swig_obj[0] = args;
29819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29820 if (!SWIG_IsOK(res1)) {
29821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29822 }
29823 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29824 {
29825 PyThreadState* __tstate = wxPyBeginAllowThreads();
29826 delete_wxVisualAttributes(arg1);
29827
29828 wxPyEndAllowThreads(__tstate);
29829 if (PyErr_Occurred()) SWIG_fail;
29830 }
29831 resultobj = SWIG_Py_Void();
29832 return resultobj;
29833 fail:
29834 return NULL;
29835 }
29836
29837
29838 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29839 PyObject *resultobj = 0;
29840 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29841 wxFont *arg2 = (wxFont *) 0 ;
29842 void *argp1 = 0 ;
29843 int res1 = 0 ;
29844 void *argp2 = 0 ;
29845 int res2 = 0 ;
29846 PyObject *swig_obj[2] ;
29847
29848 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29850 if (!SWIG_IsOK(res1)) {
29851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29852 }
29853 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29854 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29855 if (!SWIG_IsOK(res2)) {
29856 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29857 }
29858 arg2 = reinterpret_cast< wxFont * >(argp2);
29859 if (arg1) (arg1)->font = *arg2;
29860
29861 resultobj = SWIG_Py_Void();
29862 return resultobj;
29863 fail:
29864 return NULL;
29865 }
29866
29867
29868 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29869 PyObject *resultobj = 0;
29870 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29871 wxFont *result = 0 ;
29872 void *argp1 = 0 ;
29873 int res1 = 0 ;
29874 PyObject *swig_obj[1] ;
29875
29876 if (!args) SWIG_fail;
29877 swig_obj[0] = args;
29878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29879 if (!SWIG_IsOK(res1)) {
29880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29881 }
29882 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29883 result = (wxFont *)& ((arg1)->font);
29884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29885 return resultobj;
29886 fail:
29887 return NULL;
29888 }
29889
29890
29891 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29892 PyObject *resultobj = 0;
29893 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29894 wxColour *arg2 = (wxColour *) 0 ;
29895 void *argp1 = 0 ;
29896 int res1 = 0 ;
29897 void *argp2 = 0 ;
29898 int res2 = 0 ;
29899 PyObject *swig_obj[2] ;
29900
29901 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29903 if (!SWIG_IsOK(res1)) {
29904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29905 }
29906 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29907 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29908 if (!SWIG_IsOK(res2)) {
29909 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29910 }
29911 arg2 = reinterpret_cast< wxColour * >(argp2);
29912 if (arg1) (arg1)->colFg = *arg2;
29913
29914 resultobj = SWIG_Py_Void();
29915 return resultobj;
29916 fail:
29917 return NULL;
29918 }
29919
29920
29921 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29922 PyObject *resultobj = 0;
29923 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29924 wxColour *result = 0 ;
29925 void *argp1 = 0 ;
29926 int res1 = 0 ;
29927 PyObject *swig_obj[1] ;
29928
29929 if (!args) SWIG_fail;
29930 swig_obj[0] = args;
29931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29932 if (!SWIG_IsOK(res1)) {
29933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29934 }
29935 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29936 result = (wxColour *)& ((arg1)->colFg);
29937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29938 return resultobj;
29939 fail:
29940 return NULL;
29941 }
29942
29943
29944 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29945 PyObject *resultobj = 0;
29946 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29947 wxColour *arg2 = (wxColour *) 0 ;
29948 void *argp1 = 0 ;
29949 int res1 = 0 ;
29950 void *argp2 = 0 ;
29951 int res2 = 0 ;
29952 PyObject *swig_obj[2] ;
29953
29954 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29956 if (!SWIG_IsOK(res1)) {
29957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29958 }
29959 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29960 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29961 if (!SWIG_IsOK(res2)) {
29962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29963 }
29964 arg2 = reinterpret_cast< wxColour * >(argp2);
29965 if (arg1) (arg1)->colBg = *arg2;
29966
29967 resultobj = SWIG_Py_Void();
29968 return resultobj;
29969 fail:
29970 return NULL;
29971 }
29972
29973
29974 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29975 PyObject *resultobj = 0;
29976 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29977 wxColour *result = 0 ;
29978 void *argp1 = 0 ;
29979 int res1 = 0 ;
29980 PyObject *swig_obj[1] ;
29981
29982 if (!args) SWIG_fail;
29983 swig_obj[0] = args;
29984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29985 if (!SWIG_IsOK(res1)) {
29986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29987 }
29988 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29989 result = (wxColour *)& ((arg1)->colBg);
29990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29991 return resultobj;
29992 fail:
29993 return NULL;
29994 }
29995
29996
29997 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29998 PyObject *obj;
29999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30000 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
30001 return SWIG_Py_Void();
30002 }
30003
30004 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30005 return SWIG_Python_InitShadowInstance(args);
30006 }
30007
30008 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30009 PyObject *resultobj = 0;
30010 wxWindow *arg1 = (wxWindow *) 0 ;
30011 int arg2 = (int) (int)-1 ;
30012 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30013 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30014 wxSize const &arg4_defvalue = wxDefaultSize ;
30015 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
30016 long arg5 = (long) 0 ;
30017 wxString const &arg6_defvalue = wxPyPanelNameStr ;
30018 wxString *arg6 = (wxString *) &arg6_defvalue ;
30019 wxWindow *result = 0 ;
30020 void *argp1 = 0 ;
30021 int res1 = 0 ;
30022 int val2 ;
30023 int ecode2 = 0 ;
30024 wxPoint temp3 ;
30025 wxSize temp4 ;
30026 long val5 ;
30027 int ecode5 = 0 ;
30028 bool temp6 = false ;
30029 PyObject * obj0 = 0 ;
30030 PyObject * obj1 = 0 ;
30031 PyObject * obj2 = 0 ;
30032 PyObject * obj3 = 0 ;
30033 PyObject * obj4 = 0 ;
30034 PyObject * obj5 = 0 ;
30035 char * kwnames[] = {
30036 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30037 };
30038
30039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30041 if (!SWIG_IsOK(res1)) {
30042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
30043 }
30044 arg1 = reinterpret_cast< wxWindow * >(argp1);
30045 if (obj1) {
30046 ecode2 = SWIG_AsVal_int(obj1, &val2);
30047 if (!SWIG_IsOK(ecode2)) {
30048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
30049 }
30050 arg2 = static_cast< int >(val2);
30051 }
30052 if (obj2) {
30053 {
30054 arg3 = &temp3;
30055 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30056 }
30057 }
30058 if (obj3) {
30059 {
30060 arg4 = &temp4;
30061 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
30062 }
30063 }
30064 if (obj4) {
30065 ecode5 = SWIG_AsVal_long(obj4, &val5);
30066 if (!SWIG_IsOK(ecode5)) {
30067 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
30068 }
30069 arg5 = static_cast< long >(val5);
30070 }
30071 if (obj5) {
30072 {
30073 arg6 = wxString_in_helper(obj5);
30074 if (arg6 == NULL) SWIG_fail;
30075 temp6 = true;
30076 }
30077 }
30078 {
30079 if (!wxPyCheckForApp()) SWIG_fail;
30080 PyThreadState* __tstate = wxPyBeginAllowThreads();
30081 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
30082 wxPyEndAllowThreads(__tstate);
30083 if (PyErr_Occurred()) SWIG_fail;
30084 }
30085 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
30086 {
30087 if (temp6)
30088 delete arg6;
30089 }
30090 return resultobj;
30091 fail:
30092 {
30093 if (temp6)
30094 delete arg6;
30095 }
30096 return NULL;
30097 }
30098
30099
30100 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30101 PyObject *resultobj = 0;
30102 wxWindow *result = 0 ;
30103
30104 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
30105 {
30106 if (!wxPyCheckForApp()) SWIG_fail;
30107 PyThreadState* __tstate = wxPyBeginAllowThreads();
30108 result = (wxWindow *)new wxWindow();
30109 wxPyEndAllowThreads(__tstate);
30110 if (PyErr_Occurred()) SWIG_fail;
30111 }
30112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
30113 return resultobj;
30114 fail:
30115 return NULL;
30116 }
30117
30118
30119 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30120 PyObject *resultobj = 0;
30121 wxWindow *arg1 = (wxWindow *) 0 ;
30122 wxWindow *arg2 = (wxWindow *) 0 ;
30123 int arg3 = (int) (int)-1 ;
30124 wxPoint const &arg4_defvalue = wxDefaultPosition ;
30125 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
30126 wxSize const &arg5_defvalue = wxDefaultSize ;
30127 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
30128 long arg6 = (long) 0 ;
30129 wxString const &arg7_defvalue = wxPyPanelNameStr ;
30130 wxString *arg7 = (wxString *) &arg7_defvalue ;
30131 bool result;
30132 void *argp1 = 0 ;
30133 int res1 = 0 ;
30134 void *argp2 = 0 ;
30135 int res2 = 0 ;
30136 int val3 ;
30137 int ecode3 = 0 ;
30138 wxPoint temp4 ;
30139 wxSize temp5 ;
30140 long val6 ;
30141 int ecode6 = 0 ;
30142 bool temp7 = false ;
30143 PyObject * obj0 = 0 ;
30144 PyObject * obj1 = 0 ;
30145 PyObject * obj2 = 0 ;
30146 PyObject * obj3 = 0 ;
30147 PyObject * obj4 = 0 ;
30148 PyObject * obj5 = 0 ;
30149 PyObject * obj6 = 0 ;
30150 char * kwnames[] = {
30151 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
30152 };
30153
30154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
30155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30156 if (!SWIG_IsOK(res1)) {
30157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
30158 }
30159 arg1 = reinterpret_cast< wxWindow * >(argp1);
30160 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30161 if (!SWIG_IsOK(res2)) {
30162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
30163 }
30164 arg2 = reinterpret_cast< wxWindow * >(argp2);
30165 if (obj2) {
30166 ecode3 = SWIG_AsVal_int(obj2, &val3);
30167 if (!SWIG_IsOK(ecode3)) {
30168 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
30169 }
30170 arg3 = static_cast< int >(val3);
30171 }
30172 if (obj3) {
30173 {
30174 arg4 = &temp4;
30175 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
30176 }
30177 }
30178 if (obj4) {
30179 {
30180 arg5 = &temp5;
30181 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
30182 }
30183 }
30184 if (obj5) {
30185 ecode6 = SWIG_AsVal_long(obj5, &val6);
30186 if (!SWIG_IsOK(ecode6)) {
30187 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
30188 }
30189 arg6 = static_cast< long >(val6);
30190 }
30191 if (obj6) {
30192 {
30193 arg7 = wxString_in_helper(obj6);
30194 if (arg7 == NULL) SWIG_fail;
30195 temp7 = true;
30196 }
30197 }
30198 {
30199 PyThreadState* __tstate = wxPyBeginAllowThreads();
30200 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
30201 wxPyEndAllowThreads(__tstate);
30202 if (PyErr_Occurred()) SWIG_fail;
30203 }
30204 {
30205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30206 }
30207 {
30208 if (temp7)
30209 delete arg7;
30210 }
30211 return resultobj;
30212 fail:
30213 {
30214 if (temp7)
30215 delete arg7;
30216 }
30217 return NULL;
30218 }
30219
30220
30221 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30222 PyObject *resultobj = 0;
30223 wxWindow *arg1 = (wxWindow *) 0 ;
30224 bool arg2 = (bool) false ;
30225 bool result;
30226 void *argp1 = 0 ;
30227 int res1 = 0 ;
30228 bool val2 ;
30229 int ecode2 = 0 ;
30230 PyObject * obj0 = 0 ;
30231 PyObject * obj1 = 0 ;
30232 char * kwnames[] = {
30233 (char *) "self",(char *) "force", NULL
30234 };
30235
30236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
30237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30238 if (!SWIG_IsOK(res1)) {
30239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
30240 }
30241 arg1 = reinterpret_cast< wxWindow * >(argp1);
30242 if (obj1) {
30243 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30244 if (!SWIG_IsOK(ecode2)) {
30245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
30246 }
30247 arg2 = static_cast< bool >(val2);
30248 }
30249 {
30250 PyThreadState* __tstate = wxPyBeginAllowThreads();
30251 result = (bool)(arg1)->Close(arg2);
30252 wxPyEndAllowThreads(__tstate);
30253 if (PyErr_Occurred()) SWIG_fail;
30254 }
30255 {
30256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30257 }
30258 return resultobj;
30259 fail:
30260 return NULL;
30261 }
30262
30263
30264 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30265 PyObject *resultobj = 0;
30266 wxWindow *arg1 = (wxWindow *) 0 ;
30267 bool result;
30268 void *argp1 = 0 ;
30269 int res1 = 0 ;
30270 PyObject *swig_obj[1] ;
30271
30272 if (!args) SWIG_fail;
30273 swig_obj[0] = args;
30274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30275 if (!SWIG_IsOK(res1)) {
30276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
30277 }
30278 arg1 = reinterpret_cast< wxWindow * >(argp1);
30279 {
30280 PyThreadState* __tstate = wxPyBeginAllowThreads();
30281 result = (bool)(arg1)->Destroy();
30282 wxPyEndAllowThreads(__tstate);
30283 if (PyErr_Occurred()) SWIG_fail;
30284 }
30285 {
30286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30287 }
30288 return resultobj;
30289 fail:
30290 return NULL;
30291 }
30292
30293
30294 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30295 PyObject *resultobj = 0;
30296 wxWindow *arg1 = (wxWindow *) 0 ;
30297 bool result;
30298 void *argp1 = 0 ;
30299 int res1 = 0 ;
30300 PyObject *swig_obj[1] ;
30301
30302 if (!args) SWIG_fail;
30303 swig_obj[0] = args;
30304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30305 if (!SWIG_IsOK(res1)) {
30306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
30307 }
30308 arg1 = reinterpret_cast< wxWindow * >(argp1);
30309 {
30310 PyThreadState* __tstate = wxPyBeginAllowThreads();
30311 result = (bool)(arg1)->DestroyChildren();
30312 wxPyEndAllowThreads(__tstate);
30313 if (PyErr_Occurred()) SWIG_fail;
30314 }
30315 {
30316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30317 }
30318 return resultobj;
30319 fail:
30320 return NULL;
30321 }
30322
30323
30324 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30325 PyObject *resultobj = 0;
30326 wxWindow *arg1 = (wxWindow *) 0 ;
30327 bool result;
30328 void *argp1 = 0 ;
30329 int res1 = 0 ;
30330 PyObject *swig_obj[1] ;
30331
30332 if (!args) SWIG_fail;
30333 swig_obj[0] = args;
30334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30335 if (!SWIG_IsOK(res1)) {
30336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
30337 }
30338 arg1 = reinterpret_cast< wxWindow * >(argp1);
30339 {
30340 PyThreadState* __tstate = wxPyBeginAllowThreads();
30341 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
30342 wxPyEndAllowThreads(__tstate);
30343 if (PyErr_Occurred()) SWIG_fail;
30344 }
30345 {
30346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30347 }
30348 return resultobj;
30349 fail:
30350 return NULL;
30351 }
30352
30353
30354 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30355 PyObject *resultobj = 0;
30356 wxWindow *arg1 = (wxWindow *) 0 ;
30357 wxString *arg2 = 0 ;
30358 void *argp1 = 0 ;
30359 int res1 = 0 ;
30360 bool temp2 = false ;
30361 PyObject * obj0 = 0 ;
30362 PyObject * obj1 = 0 ;
30363 char * kwnames[] = {
30364 (char *) "self",(char *) "label", NULL
30365 };
30366
30367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
30368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30369 if (!SWIG_IsOK(res1)) {
30370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
30371 }
30372 arg1 = reinterpret_cast< wxWindow * >(argp1);
30373 {
30374 arg2 = wxString_in_helper(obj1);
30375 if (arg2 == NULL) SWIG_fail;
30376 temp2 = true;
30377 }
30378 {
30379 PyThreadState* __tstate = wxPyBeginAllowThreads();
30380 (arg1)->SetLabel((wxString const &)*arg2);
30381 wxPyEndAllowThreads(__tstate);
30382 if (PyErr_Occurred()) SWIG_fail;
30383 }
30384 resultobj = SWIG_Py_Void();
30385 {
30386 if (temp2)
30387 delete arg2;
30388 }
30389 return resultobj;
30390 fail:
30391 {
30392 if (temp2)
30393 delete arg2;
30394 }
30395 return NULL;
30396 }
30397
30398
30399 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30400 PyObject *resultobj = 0;
30401 wxWindow *arg1 = (wxWindow *) 0 ;
30402 wxString result;
30403 void *argp1 = 0 ;
30404 int res1 = 0 ;
30405 PyObject *swig_obj[1] ;
30406
30407 if (!args) SWIG_fail;
30408 swig_obj[0] = args;
30409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30410 if (!SWIG_IsOK(res1)) {
30411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30412 }
30413 arg1 = reinterpret_cast< wxWindow * >(argp1);
30414 {
30415 PyThreadState* __tstate = wxPyBeginAllowThreads();
30416 result = ((wxWindow const *)arg1)->GetLabel();
30417 wxPyEndAllowThreads(__tstate);
30418 if (PyErr_Occurred()) SWIG_fail;
30419 }
30420 {
30421 #if wxUSE_UNICODE
30422 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30423 #else
30424 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30425 #endif
30426 }
30427 return resultobj;
30428 fail:
30429 return NULL;
30430 }
30431
30432
30433 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30434 PyObject *resultobj = 0;
30435 wxWindow *arg1 = (wxWindow *) 0 ;
30436 wxString *arg2 = 0 ;
30437 void *argp1 = 0 ;
30438 int res1 = 0 ;
30439 bool temp2 = false ;
30440 PyObject * obj0 = 0 ;
30441 PyObject * obj1 = 0 ;
30442 char * kwnames[] = {
30443 (char *) "self",(char *) "name", NULL
30444 };
30445
30446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30448 if (!SWIG_IsOK(res1)) {
30449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30450 }
30451 arg1 = reinterpret_cast< wxWindow * >(argp1);
30452 {
30453 arg2 = wxString_in_helper(obj1);
30454 if (arg2 == NULL) SWIG_fail;
30455 temp2 = true;
30456 }
30457 {
30458 PyThreadState* __tstate = wxPyBeginAllowThreads();
30459 (arg1)->SetName((wxString const &)*arg2);
30460 wxPyEndAllowThreads(__tstate);
30461 if (PyErr_Occurred()) SWIG_fail;
30462 }
30463 resultobj = SWIG_Py_Void();
30464 {
30465 if (temp2)
30466 delete arg2;
30467 }
30468 return resultobj;
30469 fail:
30470 {
30471 if (temp2)
30472 delete arg2;
30473 }
30474 return NULL;
30475 }
30476
30477
30478 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30479 PyObject *resultobj = 0;
30480 wxWindow *arg1 = (wxWindow *) 0 ;
30481 wxString result;
30482 void *argp1 = 0 ;
30483 int res1 = 0 ;
30484 PyObject *swig_obj[1] ;
30485
30486 if (!args) SWIG_fail;
30487 swig_obj[0] = args;
30488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30489 if (!SWIG_IsOK(res1)) {
30490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30491 }
30492 arg1 = reinterpret_cast< wxWindow * >(argp1);
30493 {
30494 PyThreadState* __tstate = wxPyBeginAllowThreads();
30495 result = ((wxWindow const *)arg1)->GetName();
30496 wxPyEndAllowThreads(__tstate);
30497 if (PyErr_Occurred()) SWIG_fail;
30498 }
30499 {
30500 #if wxUSE_UNICODE
30501 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30502 #else
30503 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30504 #endif
30505 }
30506 return resultobj;
30507 fail:
30508 return NULL;
30509 }
30510
30511
30512 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30513 PyObject *resultobj = 0;
30514 wxWindow *arg1 = (wxWindow *) 0 ;
30515 wxWindowVariant arg2 ;
30516 void *argp1 = 0 ;
30517 int res1 = 0 ;
30518 int val2 ;
30519 int ecode2 = 0 ;
30520 PyObject * obj0 = 0 ;
30521 PyObject * obj1 = 0 ;
30522 char * kwnames[] = {
30523 (char *) "self",(char *) "variant", NULL
30524 };
30525
30526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30528 if (!SWIG_IsOK(res1)) {
30529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30530 }
30531 arg1 = reinterpret_cast< wxWindow * >(argp1);
30532 ecode2 = SWIG_AsVal_int(obj1, &val2);
30533 if (!SWIG_IsOK(ecode2)) {
30534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30535 }
30536 arg2 = static_cast< wxWindowVariant >(val2);
30537 {
30538 PyThreadState* __tstate = wxPyBeginAllowThreads();
30539 (arg1)->SetWindowVariant(arg2);
30540 wxPyEndAllowThreads(__tstate);
30541 if (PyErr_Occurred()) SWIG_fail;
30542 }
30543 resultobj = SWIG_Py_Void();
30544 return resultobj;
30545 fail:
30546 return NULL;
30547 }
30548
30549
30550 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30551 PyObject *resultobj = 0;
30552 wxWindow *arg1 = (wxWindow *) 0 ;
30553 wxWindowVariant result;
30554 void *argp1 = 0 ;
30555 int res1 = 0 ;
30556 PyObject *swig_obj[1] ;
30557
30558 if (!args) SWIG_fail;
30559 swig_obj[0] = args;
30560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30561 if (!SWIG_IsOK(res1)) {
30562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30563 }
30564 arg1 = reinterpret_cast< wxWindow * >(argp1);
30565 {
30566 PyThreadState* __tstate = wxPyBeginAllowThreads();
30567 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30568 wxPyEndAllowThreads(__tstate);
30569 if (PyErr_Occurred()) SWIG_fail;
30570 }
30571 resultobj = SWIG_From_int(static_cast< int >(result));
30572 return resultobj;
30573 fail:
30574 return NULL;
30575 }
30576
30577
30578 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30579 PyObject *resultobj = 0;
30580 wxWindow *arg1 = (wxWindow *) 0 ;
30581 int arg2 ;
30582 void *argp1 = 0 ;
30583 int res1 = 0 ;
30584 int val2 ;
30585 int ecode2 = 0 ;
30586 PyObject * obj0 = 0 ;
30587 PyObject * obj1 = 0 ;
30588 char * kwnames[] = {
30589 (char *) "self",(char *) "winid", NULL
30590 };
30591
30592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30594 if (!SWIG_IsOK(res1)) {
30595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30596 }
30597 arg1 = reinterpret_cast< wxWindow * >(argp1);
30598 ecode2 = SWIG_AsVal_int(obj1, &val2);
30599 if (!SWIG_IsOK(ecode2)) {
30600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30601 }
30602 arg2 = static_cast< int >(val2);
30603 {
30604 PyThreadState* __tstate = wxPyBeginAllowThreads();
30605 (arg1)->SetId(arg2);
30606 wxPyEndAllowThreads(__tstate);
30607 if (PyErr_Occurred()) SWIG_fail;
30608 }
30609 resultobj = SWIG_Py_Void();
30610 return resultobj;
30611 fail:
30612 return NULL;
30613 }
30614
30615
30616 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30617 PyObject *resultobj = 0;
30618 wxWindow *arg1 = (wxWindow *) 0 ;
30619 int result;
30620 void *argp1 = 0 ;
30621 int res1 = 0 ;
30622 PyObject *swig_obj[1] ;
30623
30624 if (!args) SWIG_fail;
30625 swig_obj[0] = args;
30626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30627 if (!SWIG_IsOK(res1)) {
30628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30629 }
30630 arg1 = reinterpret_cast< wxWindow * >(argp1);
30631 {
30632 PyThreadState* __tstate = wxPyBeginAllowThreads();
30633 result = (int)((wxWindow const *)arg1)->GetId();
30634 wxPyEndAllowThreads(__tstate);
30635 if (PyErr_Occurred()) SWIG_fail;
30636 }
30637 resultobj = SWIG_From_int(static_cast< int >(result));
30638 return resultobj;
30639 fail:
30640 return NULL;
30641 }
30642
30643
30644 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30645 PyObject *resultobj = 0;
30646 int result;
30647
30648 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30649 {
30650 PyThreadState* __tstate = wxPyBeginAllowThreads();
30651 result = (int)wxWindow::NewControlId();
30652 wxPyEndAllowThreads(__tstate);
30653 if (PyErr_Occurred()) SWIG_fail;
30654 }
30655 resultobj = SWIG_From_int(static_cast< int >(result));
30656 return resultobj;
30657 fail:
30658 return NULL;
30659 }
30660
30661
30662 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30663 PyObject *resultobj = 0;
30664 int arg1 ;
30665 int result;
30666 int val1 ;
30667 int ecode1 = 0 ;
30668 PyObject * obj0 = 0 ;
30669 char * kwnames[] = {
30670 (char *) "winid", NULL
30671 };
30672
30673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30674 ecode1 = SWIG_AsVal_int(obj0, &val1);
30675 if (!SWIG_IsOK(ecode1)) {
30676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30677 }
30678 arg1 = static_cast< int >(val1);
30679 {
30680 PyThreadState* __tstate = wxPyBeginAllowThreads();
30681 result = (int)wxWindow::NextControlId(arg1);
30682 wxPyEndAllowThreads(__tstate);
30683 if (PyErr_Occurred()) SWIG_fail;
30684 }
30685 resultobj = SWIG_From_int(static_cast< int >(result));
30686 return resultobj;
30687 fail:
30688 return NULL;
30689 }
30690
30691
30692 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30693 PyObject *resultobj = 0;
30694 int arg1 ;
30695 int result;
30696 int val1 ;
30697 int ecode1 = 0 ;
30698 PyObject * obj0 = 0 ;
30699 char * kwnames[] = {
30700 (char *) "winid", NULL
30701 };
30702
30703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30704 ecode1 = SWIG_AsVal_int(obj0, &val1);
30705 if (!SWIG_IsOK(ecode1)) {
30706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30707 }
30708 arg1 = static_cast< int >(val1);
30709 {
30710 PyThreadState* __tstate = wxPyBeginAllowThreads();
30711 result = (int)wxWindow::PrevControlId(arg1);
30712 wxPyEndAllowThreads(__tstate);
30713 if (PyErr_Occurred()) SWIG_fail;
30714 }
30715 resultobj = SWIG_From_int(static_cast< int >(result));
30716 return resultobj;
30717 fail:
30718 return NULL;
30719 }
30720
30721
30722 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30723 PyObject *resultobj = 0;
30724 wxWindow *arg1 = (wxWindow *) 0 ;
30725 wxLayoutDirection result;
30726 void *argp1 = 0 ;
30727 int res1 = 0 ;
30728 PyObject *swig_obj[1] ;
30729
30730 if (!args) SWIG_fail;
30731 swig_obj[0] = args;
30732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30733 if (!SWIG_IsOK(res1)) {
30734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30735 }
30736 arg1 = reinterpret_cast< wxWindow * >(argp1);
30737 {
30738 PyThreadState* __tstate = wxPyBeginAllowThreads();
30739 result = ((wxWindow const *)arg1)->GetLayoutDirection();
30740 wxPyEndAllowThreads(__tstate);
30741 if (PyErr_Occurred()) SWIG_fail;
30742 }
30743 resultobj = SWIG_NewPointerObj((new wxLayoutDirection(static_cast< const wxLayoutDirection& >(result))), SWIGTYPE_p_wxLayoutDirection, SWIG_POINTER_OWN | 0 );
30744 return resultobj;
30745 fail:
30746 return NULL;
30747 }
30748
30749
30750 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30751 PyObject *resultobj = 0;
30752 wxWindow *arg1 = (wxWindow *) 0 ;
30753 wxLayoutDirection arg2 ;
30754 void *argp1 = 0 ;
30755 int res1 = 0 ;
30756 void *argp2 ;
30757 int res2 = 0 ;
30758 PyObject * obj0 = 0 ;
30759 PyObject * obj1 = 0 ;
30760 char * kwnames[] = {
30761 (char *) "self",(char *) "dir", NULL
30762 };
30763
30764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
30765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30766 if (!SWIG_IsOK(res1)) {
30767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
30768 }
30769 arg1 = reinterpret_cast< wxWindow * >(argp1);
30770 {
30771 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxLayoutDirection, 0 | 0);
30772 if (!SWIG_IsOK(res2)) {
30773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30774 }
30775 if (!argp2) {
30776 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
30777 } else {
30778 wxLayoutDirection * temp = reinterpret_cast< wxLayoutDirection * >(argp2);
30779 arg2 = *temp;
30780 if (SWIG_IsNewObj(res2)) delete temp;
30781 }
30782 }
30783 {
30784 PyThreadState* __tstate = wxPyBeginAllowThreads();
30785 (arg1)->SetLayoutDirection(arg2);
30786 wxPyEndAllowThreads(__tstate);
30787 if (PyErr_Occurred()) SWIG_fail;
30788 }
30789 resultobj = SWIG_Py_Void();
30790 return resultobj;
30791 fail:
30792 return NULL;
30793 }
30794
30795
30796 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30797 PyObject *resultobj = 0;
30798 wxWindow *arg1 = (wxWindow *) 0 ;
30799 int arg2 ;
30800 int arg3 ;
30801 int arg4 ;
30802 int result;
30803 void *argp1 = 0 ;
30804 int res1 = 0 ;
30805 int val2 ;
30806 int ecode2 = 0 ;
30807 int val3 ;
30808 int ecode3 = 0 ;
30809 int val4 ;
30810 int ecode4 = 0 ;
30811 PyObject * obj0 = 0 ;
30812 PyObject * obj1 = 0 ;
30813 PyObject * obj2 = 0 ;
30814 PyObject * obj3 = 0 ;
30815 char * kwnames[] = {
30816 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
30817 };
30818
30819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30821 if (!SWIG_IsOK(res1)) {
30822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
30823 }
30824 arg1 = reinterpret_cast< wxWindow * >(argp1);
30825 ecode2 = SWIG_AsVal_int(obj1, &val2);
30826 if (!SWIG_IsOK(ecode2)) {
30827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
30828 }
30829 arg2 = static_cast< int >(val2);
30830 ecode3 = SWIG_AsVal_int(obj2, &val3);
30831 if (!SWIG_IsOK(ecode3)) {
30832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
30833 }
30834 arg3 = static_cast< int >(val3);
30835 ecode4 = SWIG_AsVal_int(obj3, &val4);
30836 if (!SWIG_IsOK(ecode4)) {
30837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
30838 }
30839 arg4 = static_cast< int >(val4);
30840 {
30841 PyThreadState* __tstate = wxPyBeginAllowThreads();
30842 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
30843 wxPyEndAllowThreads(__tstate);
30844 if (PyErr_Occurred()) SWIG_fail;
30845 }
30846 resultobj = SWIG_From_int(static_cast< int >(result));
30847 return resultobj;
30848 fail:
30849 return NULL;
30850 }
30851
30852
30853 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30854 PyObject *resultobj = 0;
30855 wxWindow *arg1 = (wxWindow *) 0 ;
30856 wxSize *arg2 = 0 ;
30857 void *argp1 = 0 ;
30858 int res1 = 0 ;
30859 wxSize temp2 ;
30860 PyObject * obj0 = 0 ;
30861 PyObject * obj1 = 0 ;
30862 char * kwnames[] = {
30863 (char *) "self",(char *) "size", NULL
30864 };
30865
30866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30868 if (!SWIG_IsOK(res1)) {
30869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30870 }
30871 arg1 = reinterpret_cast< wxWindow * >(argp1);
30872 {
30873 arg2 = &temp2;
30874 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30875 }
30876 {
30877 PyThreadState* __tstate = wxPyBeginAllowThreads();
30878 (arg1)->SetSize((wxSize const &)*arg2);
30879 wxPyEndAllowThreads(__tstate);
30880 if (PyErr_Occurred()) SWIG_fail;
30881 }
30882 resultobj = SWIG_Py_Void();
30883 return resultobj;
30884 fail:
30885 return NULL;
30886 }
30887
30888
30889 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30890 PyObject *resultobj = 0;
30891 wxWindow *arg1 = (wxWindow *) 0 ;
30892 int arg2 ;
30893 int arg3 ;
30894 int arg4 ;
30895 int arg5 ;
30896 int arg6 = (int) wxSIZE_AUTO ;
30897 void *argp1 = 0 ;
30898 int res1 = 0 ;
30899 int val2 ;
30900 int ecode2 = 0 ;
30901 int val3 ;
30902 int ecode3 = 0 ;
30903 int val4 ;
30904 int ecode4 = 0 ;
30905 int val5 ;
30906 int ecode5 = 0 ;
30907 int val6 ;
30908 int ecode6 = 0 ;
30909 PyObject * obj0 = 0 ;
30910 PyObject * obj1 = 0 ;
30911 PyObject * obj2 = 0 ;
30912 PyObject * obj3 = 0 ;
30913 PyObject * obj4 = 0 ;
30914 PyObject * obj5 = 0 ;
30915 char * kwnames[] = {
30916 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30917 };
30918
30919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30921 if (!SWIG_IsOK(res1)) {
30922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30923 }
30924 arg1 = reinterpret_cast< wxWindow * >(argp1);
30925 ecode2 = SWIG_AsVal_int(obj1, &val2);
30926 if (!SWIG_IsOK(ecode2)) {
30927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30928 }
30929 arg2 = static_cast< int >(val2);
30930 ecode3 = SWIG_AsVal_int(obj2, &val3);
30931 if (!SWIG_IsOK(ecode3)) {
30932 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30933 }
30934 arg3 = static_cast< int >(val3);
30935 ecode4 = SWIG_AsVal_int(obj3, &val4);
30936 if (!SWIG_IsOK(ecode4)) {
30937 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30938 }
30939 arg4 = static_cast< int >(val4);
30940 ecode5 = SWIG_AsVal_int(obj4, &val5);
30941 if (!SWIG_IsOK(ecode5)) {
30942 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30943 }
30944 arg5 = static_cast< int >(val5);
30945 if (obj5) {
30946 ecode6 = SWIG_AsVal_int(obj5, &val6);
30947 if (!SWIG_IsOK(ecode6)) {
30948 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30949 }
30950 arg6 = static_cast< int >(val6);
30951 }
30952 {
30953 PyThreadState* __tstate = wxPyBeginAllowThreads();
30954 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30955 wxPyEndAllowThreads(__tstate);
30956 if (PyErr_Occurred()) SWIG_fail;
30957 }
30958 resultobj = SWIG_Py_Void();
30959 return resultobj;
30960 fail:
30961 return NULL;
30962 }
30963
30964
30965 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30966 PyObject *resultobj = 0;
30967 wxWindow *arg1 = (wxWindow *) 0 ;
30968 wxRect *arg2 = 0 ;
30969 int arg3 = (int) wxSIZE_AUTO ;
30970 void *argp1 = 0 ;
30971 int res1 = 0 ;
30972 wxRect temp2 ;
30973 int val3 ;
30974 int ecode3 = 0 ;
30975 PyObject * obj0 = 0 ;
30976 PyObject * obj1 = 0 ;
30977 PyObject * obj2 = 0 ;
30978 char * kwnames[] = {
30979 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30980 };
30981
30982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30984 if (!SWIG_IsOK(res1)) {
30985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30986 }
30987 arg1 = reinterpret_cast< wxWindow * >(argp1);
30988 {
30989 arg2 = &temp2;
30990 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30991 }
30992 if (obj2) {
30993 ecode3 = SWIG_AsVal_int(obj2, &val3);
30994 if (!SWIG_IsOK(ecode3)) {
30995 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30996 }
30997 arg3 = static_cast< int >(val3);
30998 }
30999 {
31000 PyThreadState* __tstate = wxPyBeginAllowThreads();
31001 (arg1)->SetSize((wxRect const &)*arg2,arg3);
31002 wxPyEndAllowThreads(__tstate);
31003 if (PyErr_Occurred()) SWIG_fail;
31004 }
31005 resultobj = SWIG_Py_Void();
31006 return resultobj;
31007 fail:
31008 return NULL;
31009 }
31010
31011
31012 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31013 PyObject *resultobj = 0;
31014 wxWindow *arg1 = (wxWindow *) 0 ;
31015 int arg2 ;
31016 int arg3 ;
31017 void *argp1 = 0 ;
31018 int res1 = 0 ;
31019 int val2 ;
31020 int ecode2 = 0 ;
31021 int val3 ;
31022 int ecode3 = 0 ;
31023 PyObject * obj0 = 0 ;
31024 PyObject * obj1 = 0 ;
31025 PyObject * obj2 = 0 ;
31026 char * kwnames[] = {
31027 (char *) "self",(char *) "width",(char *) "height", NULL
31028 };
31029
31030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31032 if (!SWIG_IsOK(res1)) {
31033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31034 }
31035 arg1 = reinterpret_cast< wxWindow * >(argp1);
31036 ecode2 = SWIG_AsVal_int(obj1, &val2);
31037 if (!SWIG_IsOK(ecode2)) {
31038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
31039 }
31040 arg2 = static_cast< int >(val2);
31041 ecode3 = SWIG_AsVal_int(obj2, &val3);
31042 if (!SWIG_IsOK(ecode3)) {
31043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
31044 }
31045 arg3 = static_cast< int >(val3);
31046 {
31047 PyThreadState* __tstate = wxPyBeginAllowThreads();
31048 (arg1)->SetSize(arg2,arg3);
31049 wxPyEndAllowThreads(__tstate);
31050 if (PyErr_Occurred()) SWIG_fail;
31051 }
31052 resultobj = SWIG_Py_Void();
31053 return resultobj;
31054 fail:
31055 return NULL;
31056 }
31057
31058
31059 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31060 PyObject *resultobj = 0;
31061 wxWindow *arg1 = (wxWindow *) 0 ;
31062 wxPoint *arg2 = 0 ;
31063 int arg3 = (int) wxSIZE_USE_EXISTING ;
31064 void *argp1 = 0 ;
31065 int res1 = 0 ;
31066 wxPoint temp2 ;
31067 int val3 ;
31068 int ecode3 = 0 ;
31069 PyObject * obj0 = 0 ;
31070 PyObject * obj1 = 0 ;
31071 PyObject * obj2 = 0 ;
31072 char * kwnames[] = {
31073 (char *) "self",(char *) "pt",(char *) "flags", NULL
31074 };
31075
31076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31078 if (!SWIG_IsOK(res1)) {
31079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
31080 }
31081 arg1 = reinterpret_cast< wxWindow * >(argp1);
31082 {
31083 arg2 = &temp2;
31084 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31085 }
31086 if (obj2) {
31087 ecode3 = SWIG_AsVal_int(obj2, &val3);
31088 if (!SWIG_IsOK(ecode3)) {
31089 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
31090 }
31091 arg3 = static_cast< int >(val3);
31092 }
31093 {
31094 PyThreadState* __tstate = wxPyBeginAllowThreads();
31095 (arg1)->Move((wxPoint const &)*arg2,arg3);
31096 wxPyEndAllowThreads(__tstate);
31097 if (PyErr_Occurred()) SWIG_fail;
31098 }
31099 resultobj = SWIG_Py_Void();
31100 return resultobj;
31101 fail:
31102 return NULL;
31103 }
31104
31105
31106 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31107 PyObject *resultobj = 0;
31108 wxWindow *arg1 = (wxWindow *) 0 ;
31109 int arg2 ;
31110 int arg3 ;
31111 int arg4 = (int) wxSIZE_USE_EXISTING ;
31112 void *argp1 = 0 ;
31113 int res1 = 0 ;
31114 int val2 ;
31115 int ecode2 = 0 ;
31116 int val3 ;
31117 int ecode3 = 0 ;
31118 int val4 ;
31119 int ecode4 = 0 ;
31120 PyObject * obj0 = 0 ;
31121 PyObject * obj1 = 0 ;
31122 PyObject * obj2 = 0 ;
31123 PyObject * obj3 = 0 ;
31124 char * kwnames[] = {
31125 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
31126 };
31127
31128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31130 if (!SWIG_IsOK(res1)) {
31131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
31132 }
31133 arg1 = reinterpret_cast< wxWindow * >(argp1);
31134 ecode2 = SWIG_AsVal_int(obj1, &val2);
31135 if (!SWIG_IsOK(ecode2)) {
31136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
31137 }
31138 arg2 = static_cast< int >(val2);
31139 ecode3 = SWIG_AsVal_int(obj2, &val3);
31140 if (!SWIG_IsOK(ecode3)) {
31141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
31142 }
31143 arg3 = static_cast< int >(val3);
31144 if (obj3) {
31145 ecode4 = SWIG_AsVal_int(obj3, &val4);
31146 if (!SWIG_IsOK(ecode4)) {
31147 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
31148 }
31149 arg4 = static_cast< int >(val4);
31150 }
31151 {
31152 PyThreadState* __tstate = wxPyBeginAllowThreads();
31153 (arg1)->Move(arg2,arg3,arg4);
31154 wxPyEndAllowThreads(__tstate);
31155 if (PyErr_Occurred()) SWIG_fail;
31156 }
31157 resultobj = SWIG_Py_Void();
31158 return resultobj;
31159 fail:
31160 return NULL;
31161 }
31162
31163
31164 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31165 PyObject *resultobj = 0;
31166 wxWindow *arg1 = (wxWindow *) 0 ;
31167 wxSize const &arg2_defvalue = wxDefaultSize ;
31168 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
31169 void *argp1 = 0 ;
31170 int res1 = 0 ;
31171 wxSize temp2 ;
31172 PyObject * obj0 = 0 ;
31173 PyObject * obj1 = 0 ;
31174 char * kwnames[] = {
31175 (char *) "self",(char *) "size", NULL
31176 };
31177
31178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
31179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31180 if (!SWIG_IsOK(res1)) {
31181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31182 }
31183 arg1 = reinterpret_cast< wxWindow * >(argp1);
31184 if (obj1) {
31185 {
31186 arg2 = &temp2;
31187 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31188 }
31189 }
31190 {
31191 PyThreadState* __tstate = wxPyBeginAllowThreads();
31192 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
31193 wxPyEndAllowThreads(__tstate);
31194 if (PyErr_Occurred()) SWIG_fail;
31195 }
31196 resultobj = SWIG_Py_Void();
31197 return resultobj;
31198 fail:
31199 return NULL;
31200 }
31201
31202
31203 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31204 PyObject *resultobj = 0;
31205 wxWindow *arg1 = (wxWindow *) 0 ;
31206 void *argp1 = 0 ;
31207 int res1 = 0 ;
31208 PyObject *swig_obj[1] ;
31209
31210 if (!args) SWIG_fail;
31211 swig_obj[0] = args;
31212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31213 if (!SWIG_IsOK(res1)) {
31214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
31215 }
31216 arg1 = reinterpret_cast< wxWindow * >(argp1);
31217 {
31218 PyThreadState* __tstate = wxPyBeginAllowThreads();
31219 (arg1)->Raise();
31220 wxPyEndAllowThreads(__tstate);
31221 if (PyErr_Occurred()) SWIG_fail;
31222 }
31223 resultobj = SWIG_Py_Void();
31224 return resultobj;
31225 fail:
31226 return NULL;
31227 }
31228
31229
31230 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31231 PyObject *resultobj = 0;
31232 wxWindow *arg1 = (wxWindow *) 0 ;
31233 void *argp1 = 0 ;
31234 int res1 = 0 ;
31235 PyObject *swig_obj[1] ;
31236
31237 if (!args) SWIG_fail;
31238 swig_obj[0] = args;
31239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31240 if (!SWIG_IsOK(res1)) {
31241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
31242 }
31243 arg1 = reinterpret_cast< wxWindow * >(argp1);
31244 {
31245 PyThreadState* __tstate = wxPyBeginAllowThreads();
31246 (arg1)->Lower();
31247 wxPyEndAllowThreads(__tstate);
31248 if (PyErr_Occurred()) SWIG_fail;
31249 }
31250 resultobj = SWIG_Py_Void();
31251 return resultobj;
31252 fail:
31253 return NULL;
31254 }
31255
31256
31257 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31258 PyObject *resultobj = 0;
31259 wxWindow *arg1 = (wxWindow *) 0 ;
31260 wxSize *arg2 = 0 ;
31261 void *argp1 = 0 ;
31262 int res1 = 0 ;
31263 wxSize temp2 ;
31264 PyObject * obj0 = 0 ;
31265 PyObject * obj1 = 0 ;
31266 char * kwnames[] = {
31267 (char *) "self",(char *) "size", NULL
31268 };
31269
31270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
31271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31272 if (!SWIG_IsOK(res1)) {
31273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31274 }
31275 arg1 = reinterpret_cast< wxWindow * >(argp1);
31276 {
31277 arg2 = &temp2;
31278 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31279 }
31280 {
31281 PyThreadState* __tstate = wxPyBeginAllowThreads();
31282 (arg1)->SetClientSize((wxSize const &)*arg2);
31283 wxPyEndAllowThreads(__tstate);
31284 if (PyErr_Occurred()) SWIG_fail;
31285 }
31286 resultobj = SWIG_Py_Void();
31287 return resultobj;
31288 fail:
31289 return NULL;
31290 }
31291
31292
31293 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31294 PyObject *resultobj = 0;
31295 wxWindow *arg1 = (wxWindow *) 0 ;
31296 int arg2 ;
31297 int arg3 ;
31298 void *argp1 = 0 ;
31299 int res1 = 0 ;
31300 int val2 ;
31301 int ecode2 = 0 ;
31302 int val3 ;
31303 int ecode3 = 0 ;
31304 PyObject * obj0 = 0 ;
31305 PyObject * obj1 = 0 ;
31306 PyObject * obj2 = 0 ;
31307 char * kwnames[] = {
31308 (char *) "self",(char *) "width",(char *) "height", NULL
31309 };
31310
31311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31313 if (!SWIG_IsOK(res1)) {
31314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31315 }
31316 arg1 = reinterpret_cast< wxWindow * >(argp1);
31317 ecode2 = SWIG_AsVal_int(obj1, &val2);
31318 if (!SWIG_IsOK(ecode2)) {
31319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
31320 }
31321 arg2 = static_cast< int >(val2);
31322 ecode3 = SWIG_AsVal_int(obj2, &val3);
31323 if (!SWIG_IsOK(ecode3)) {
31324 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
31325 }
31326 arg3 = static_cast< int >(val3);
31327 {
31328 PyThreadState* __tstate = wxPyBeginAllowThreads();
31329 (arg1)->SetClientSize(arg2,arg3);
31330 wxPyEndAllowThreads(__tstate);
31331 if (PyErr_Occurred()) SWIG_fail;
31332 }
31333 resultobj = SWIG_Py_Void();
31334 return resultobj;
31335 fail:
31336 return NULL;
31337 }
31338
31339
31340 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31341 PyObject *resultobj = 0;
31342 wxWindow *arg1 = (wxWindow *) 0 ;
31343 wxRect *arg2 = 0 ;
31344 void *argp1 = 0 ;
31345 int res1 = 0 ;
31346 wxRect temp2 ;
31347 PyObject * obj0 = 0 ;
31348 PyObject * obj1 = 0 ;
31349 char * kwnames[] = {
31350 (char *) "self",(char *) "rect", NULL
31351 };
31352
31353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
31354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31355 if (!SWIG_IsOK(res1)) {
31356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
31357 }
31358 arg1 = reinterpret_cast< wxWindow * >(argp1);
31359 {
31360 arg2 = &temp2;
31361 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
31362 }
31363 {
31364 PyThreadState* __tstate = wxPyBeginAllowThreads();
31365 (arg1)->SetClientSize((wxRect const &)*arg2);
31366 wxPyEndAllowThreads(__tstate);
31367 if (PyErr_Occurred()) SWIG_fail;
31368 }
31369 resultobj = SWIG_Py_Void();
31370 return resultobj;
31371 fail:
31372 return NULL;
31373 }
31374
31375
31376 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31377 PyObject *resultobj = 0;
31378 wxWindow *arg1 = (wxWindow *) 0 ;
31379 wxPoint result;
31380 void *argp1 = 0 ;
31381 int res1 = 0 ;
31382 PyObject *swig_obj[1] ;
31383
31384 if (!args) SWIG_fail;
31385 swig_obj[0] = args;
31386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31387 if (!SWIG_IsOK(res1)) {
31388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31389 }
31390 arg1 = reinterpret_cast< wxWindow * >(argp1);
31391 {
31392 PyThreadState* __tstate = wxPyBeginAllowThreads();
31393 result = ((wxWindow const *)arg1)->GetPosition();
31394 wxPyEndAllowThreads(__tstate);
31395 if (PyErr_Occurred()) SWIG_fail;
31396 }
31397 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31398 return resultobj;
31399 fail:
31400 return NULL;
31401 }
31402
31403
31404 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31405 PyObject *resultobj = 0;
31406 wxWindow *arg1 = (wxWindow *) 0 ;
31407 int *arg2 = (int *) 0 ;
31408 int *arg3 = (int *) 0 ;
31409 void *argp1 = 0 ;
31410 int res1 = 0 ;
31411 int temp2 ;
31412 int res2 = SWIG_TMPOBJ ;
31413 int temp3 ;
31414 int res3 = SWIG_TMPOBJ ;
31415 PyObject *swig_obj[1] ;
31416
31417 arg2 = &temp2;
31418 arg3 = &temp3;
31419 if (!args) SWIG_fail;
31420 swig_obj[0] = args;
31421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31422 if (!SWIG_IsOK(res1)) {
31423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31424 }
31425 arg1 = reinterpret_cast< wxWindow * >(argp1);
31426 {
31427 PyThreadState* __tstate = wxPyBeginAllowThreads();
31428 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
31429 wxPyEndAllowThreads(__tstate);
31430 if (PyErr_Occurred()) SWIG_fail;
31431 }
31432 resultobj = SWIG_Py_Void();
31433 if (SWIG_IsTmpObj(res2)) {
31434 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31435 } else {
31436 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31437 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31438 }
31439 if (SWIG_IsTmpObj(res3)) {
31440 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31441 } else {
31442 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31443 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31444 }
31445 return resultobj;
31446 fail:
31447 return NULL;
31448 }
31449
31450
31451 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31452 PyObject *resultobj = 0;
31453 wxWindow *arg1 = (wxWindow *) 0 ;
31454 wxPoint result;
31455 void *argp1 = 0 ;
31456 int res1 = 0 ;
31457 PyObject *swig_obj[1] ;
31458
31459 if (!args) SWIG_fail;
31460 swig_obj[0] = args;
31461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31462 if (!SWIG_IsOK(res1)) {
31463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
31464 }
31465 arg1 = reinterpret_cast< wxWindow * >(argp1);
31466 {
31467 PyThreadState* __tstate = wxPyBeginAllowThreads();
31468 result = ((wxWindow const *)arg1)->GetScreenPosition();
31469 wxPyEndAllowThreads(__tstate);
31470 if (PyErr_Occurred()) SWIG_fail;
31471 }
31472 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31473 return resultobj;
31474 fail:
31475 return NULL;
31476 }
31477
31478
31479 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31480 PyObject *resultobj = 0;
31481 wxWindow *arg1 = (wxWindow *) 0 ;
31482 int *arg2 = (int *) 0 ;
31483 int *arg3 = (int *) 0 ;
31484 void *argp1 = 0 ;
31485 int res1 = 0 ;
31486 int temp2 ;
31487 int res2 = SWIG_TMPOBJ ;
31488 int temp3 ;
31489 int res3 = SWIG_TMPOBJ ;
31490 PyObject *swig_obj[1] ;
31491
31492 arg2 = &temp2;
31493 arg3 = &temp3;
31494 if (!args) SWIG_fail;
31495 swig_obj[0] = args;
31496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31497 if (!SWIG_IsOK(res1)) {
31498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31499 }
31500 arg1 = reinterpret_cast< wxWindow * >(argp1);
31501 {
31502 PyThreadState* __tstate = wxPyBeginAllowThreads();
31503 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
31504 wxPyEndAllowThreads(__tstate);
31505 if (PyErr_Occurred()) SWIG_fail;
31506 }
31507 resultobj = SWIG_Py_Void();
31508 if (SWIG_IsTmpObj(res2)) {
31509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31510 } else {
31511 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31512 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31513 }
31514 if (SWIG_IsTmpObj(res3)) {
31515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31516 } else {
31517 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31519 }
31520 return resultobj;
31521 fail:
31522 return NULL;
31523 }
31524
31525
31526 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31527 PyObject *resultobj = 0;
31528 wxWindow *arg1 = (wxWindow *) 0 ;
31529 wxRect result;
31530 void *argp1 = 0 ;
31531 int res1 = 0 ;
31532 PyObject *swig_obj[1] ;
31533
31534 if (!args) SWIG_fail;
31535 swig_obj[0] = args;
31536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31537 if (!SWIG_IsOK(res1)) {
31538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31539 }
31540 arg1 = reinterpret_cast< wxWindow * >(argp1);
31541 {
31542 PyThreadState* __tstate = wxPyBeginAllowThreads();
31543 result = ((wxWindow const *)arg1)->GetScreenRect();
31544 wxPyEndAllowThreads(__tstate);
31545 if (PyErr_Occurred()) SWIG_fail;
31546 }
31547 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31548 return resultobj;
31549 fail:
31550 return NULL;
31551 }
31552
31553
31554 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31555 PyObject *resultobj = 0;
31556 wxWindow *arg1 = (wxWindow *) 0 ;
31557 wxSize result;
31558 void *argp1 = 0 ;
31559 int res1 = 0 ;
31560 PyObject *swig_obj[1] ;
31561
31562 if (!args) SWIG_fail;
31563 swig_obj[0] = args;
31564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31565 if (!SWIG_IsOK(res1)) {
31566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31567 }
31568 arg1 = reinterpret_cast< wxWindow * >(argp1);
31569 {
31570 PyThreadState* __tstate = wxPyBeginAllowThreads();
31571 result = ((wxWindow const *)arg1)->GetSize();
31572 wxPyEndAllowThreads(__tstate);
31573 if (PyErr_Occurred()) SWIG_fail;
31574 }
31575 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31576 return resultobj;
31577 fail:
31578 return NULL;
31579 }
31580
31581
31582 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31583 PyObject *resultobj = 0;
31584 wxWindow *arg1 = (wxWindow *) 0 ;
31585 int *arg2 = (int *) 0 ;
31586 int *arg3 = (int *) 0 ;
31587 void *argp1 = 0 ;
31588 int res1 = 0 ;
31589 int temp2 ;
31590 int res2 = SWIG_TMPOBJ ;
31591 int temp3 ;
31592 int res3 = SWIG_TMPOBJ ;
31593 PyObject *swig_obj[1] ;
31594
31595 arg2 = &temp2;
31596 arg3 = &temp3;
31597 if (!args) SWIG_fail;
31598 swig_obj[0] = args;
31599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31600 if (!SWIG_IsOK(res1)) {
31601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31602 }
31603 arg1 = reinterpret_cast< wxWindow * >(argp1);
31604 {
31605 PyThreadState* __tstate = wxPyBeginAllowThreads();
31606 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31607 wxPyEndAllowThreads(__tstate);
31608 if (PyErr_Occurred()) SWIG_fail;
31609 }
31610 resultobj = SWIG_Py_Void();
31611 if (SWIG_IsTmpObj(res2)) {
31612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31613 } else {
31614 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31615 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31616 }
31617 if (SWIG_IsTmpObj(res3)) {
31618 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31619 } else {
31620 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31621 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31622 }
31623 return resultobj;
31624 fail:
31625 return NULL;
31626 }
31627
31628
31629 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31630 PyObject *resultobj = 0;
31631 wxWindow *arg1 = (wxWindow *) 0 ;
31632 wxRect result;
31633 void *argp1 = 0 ;
31634 int res1 = 0 ;
31635 PyObject *swig_obj[1] ;
31636
31637 if (!args) SWIG_fail;
31638 swig_obj[0] = args;
31639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31640 if (!SWIG_IsOK(res1)) {
31641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31642 }
31643 arg1 = reinterpret_cast< wxWindow * >(argp1);
31644 {
31645 PyThreadState* __tstate = wxPyBeginAllowThreads();
31646 result = ((wxWindow const *)arg1)->GetRect();
31647 wxPyEndAllowThreads(__tstate);
31648 if (PyErr_Occurred()) SWIG_fail;
31649 }
31650 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31651 return resultobj;
31652 fail:
31653 return NULL;
31654 }
31655
31656
31657 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31658 PyObject *resultobj = 0;
31659 wxWindow *arg1 = (wxWindow *) 0 ;
31660 wxSize result;
31661 void *argp1 = 0 ;
31662 int res1 = 0 ;
31663 PyObject *swig_obj[1] ;
31664
31665 if (!args) SWIG_fail;
31666 swig_obj[0] = args;
31667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31668 if (!SWIG_IsOK(res1)) {
31669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31670 }
31671 arg1 = reinterpret_cast< wxWindow * >(argp1);
31672 {
31673 PyThreadState* __tstate = wxPyBeginAllowThreads();
31674 result = ((wxWindow const *)arg1)->GetClientSize();
31675 wxPyEndAllowThreads(__tstate);
31676 if (PyErr_Occurred()) SWIG_fail;
31677 }
31678 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31679 return resultobj;
31680 fail:
31681 return NULL;
31682 }
31683
31684
31685 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31686 PyObject *resultobj = 0;
31687 wxWindow *arg1 = (wxWindow *) 0 ;
31688 int *arg2 = (int *) 0 ;
31689 int *arg3 = (int *) 0 ;
31690 void *argp1 = 0 ;
31691 int res1 = 0 ;
31692 int temp2 ;
31693 int res2 = SWIG_TMPOBJ ;
31694 int temp3 ;
31695 int res3 = SWIG_TMPOBJ ;
31696 PyObject *swig_obj[1] ;
31697
31698 arg2 = &temp2;
31699 arg3 = &temp3;
31700 if (!args) SWIG_fail;
31701 swig_obj[0] = args;
31702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31703 if (!SWIG_IsOK(res1)) {
31704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31705 }
31706 arg1 = reinterpret_cast< wxWindow * >(argp1);
31707 {
31708 PyThreadState* __tstate = wxPyBeginAllowThreads();
31709 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31710 wxPyEndAllowThreads(__tstate);
31711 if (PyErr_Occurred()) SWIG_fail;
31712 }
31713 resultobj = SWIG_Py_Void();
31714 if (SWIG_IsTmpObj(res2)) {
31715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31716 } else {
31717 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31719 }
31720 if (SWIG_IsTmpObj(res3)) {
31721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31722 } else {
31723 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31725 }
31726 return resultobj;
31727 fail:
31728 return NULL;
31729 }
31730
31731
31732 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31733 PyObject *resultobj = 0;
31734 wxWindow *arg1 = (wxWindow *) 0 ;
31735 wxPoint result;
31736 void *argp1 = 0 ;
31737 int res1 = 0 ;
31738 PyObject *swig_obj[1] ;
31739
31740 if (!args) SWIG_fail;
31741 swig_obj[0] = args;
31742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31743 if (!SWIG_IsOK(res1)) {
31744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31745 }
31746 arg1 = reinterpret_cast< wxWindow * >(argp1);
31747 {
31748 PyThreadState* __tstate = wxPyBeginAllowThreads();
31749 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31750 wxPyEndAllowThreads(__tstate);
31751 if (PyErr_Occurred()) SWIG_fail;
31752 }
31753 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31754 return resultobj;
31755 fail:
31756 return NULL;
31757 }
31758
31759
31760 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31761 PyObject *resultobj = 0;
31762 wxWindow *arg1 = (wxWindow *) 0 ;
31763 wxRect result;
31764 void *argp1 = 0 ;
31765 int res1 = 0 ;
31766 PyObject *swig_obj[1] ;
31767
31768 if (!args) SWIG_fail;
31769 swig_obj[0] = args;
31770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31771 if (!SWIG_IsOK(res1)) {
31772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31773 }
31774 arg1 = reinterpret_cast< wxWindow * >(argp1);
31775 {
31776 PyThreadState* __tstate = wxPyBeginAllowThreads();
31777 result = ((wxWindow const *)arg1)->GetClientRect();
31778 wxPyEndAllowThreads(__tstate);
31779 if (PyErr_Occurred()) SWIG_fail;
31780 }
31781 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31789 PyObject *resultobj = 0;
31790 wxWindow *arg1 = (wxWindow *) 0 ;
31791 wxSize result;
31792 void *argp1 = 0 ;
31793 int res1 = 0 ;
31794 PyObject *swig_obj[1] ;
31795
31796 if (!args) SWIG_fail;
31797 swig_obj[0] = args;
31798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31799 if (!SWIG_IsOK(res1)) {
31800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31801 }
31802 arg1 = reinterpret_cast< wxWindow * >(argp1);
31803 {
31804 PyThreadState* __tstate = wxPyBeginAllowThreads();
31805 result = ((wxWindow const *)arg1)->GetBestSize();
31806 wxPyEndAllowThreads(__tstate);
31807 if (PyErr_Occurred()) SWIG_fail;
31808 }
31809 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31817 PyObject *resultobj = 0;
31818 wxWindow *arg1 = (wxWindow *) 0 ;
31819 int *arg2 = (int *) 0 ;
31820 int *arg3 = (int *) 0 ;
31821 void *argp1 = 0 ;
31822 int res1 = 0 ;
31823 int temp2 ;
31824 int res2 = SWIG_TMPOBJ ;
31825 int temp3 ;
31826 int res3 = SWIG_TMPOBJ ;
31827 PyObject *swig_obj[1] ;
31828
31829 arg2 = &temp2;
31830 arg3 = &temp3;
31831 if (!args) SWIG_fail;
31832 swig_obj[0] = args;
31833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31834 if (!SWIG_IsOK(res1)) {
31835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31836 }
31837 arg1 = reinterpret_cast< wxWindow * >(argp1);
31838 {
31839 PyThreadState* __tstate = wxPyBeginAllowThreads();
31840 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31841 wxPyEndAllowThreads(__tstate);
31842 if (PyErr_Occurred()) SWIG_fail;
31843 }
31844 resultobj = SWIG_Py_Void();
31845 if (SWIG_IsTmpObj(res2)) {
31846 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31847 } else {
31848 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31849 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31850 }
31851 if (SWIG_IsTmpObj(res3)) {
31852 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31853 } else {
31854 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31856 }
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31864 PyObject *resultobj = 0;
31865 wxWindow *arg1 = (wxWindow *) 0 ;
31866 void *argp1 = 0 ;
31867 int res1 = 0 ;
31868 PyObject *swig_obj[1] ;
31869
31870 if (!args) SWIG_fail;
31871 swig_obj[0] = args;
31872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31873 if (!SWIG_IsOK(res1)) {
31874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31875 }
31876 arg1 = reinterpret_cast< wxWindow * >(argp1);
31877 {
31878 PyThreadState* __tstate = wxPyBeginAllowThreads();
31879 (arg1)->InvalidateBestSize();
31880 wxPyEndAllowThreads(__tstate);
31881 if (PyErr_Occurred()) SWIG_fail;
31882 }
31883 resultobj = SWIG_Py_Void();
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31891 PyObject *resultobj = 0;
31892 wxWindow *arg1 = (wxWindow *) 0 ;
31893 wxSize *arg2 = 0 ;
31894 void *argp1 = 0 ;
31895 int res1 = 0 ;
31896 wxSize temp2 ;
31897 PyObject * obj0 = 0 ;
31898 PyObject * obj1 = 0 ;
31899 char * kwnames[] = {
31900 (char *) "self",(char *) "size", NULL
31901 };
31902
31903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31905 if (!SWIG_IsOK(res1)) {
31906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31907 }
31908 arg1 = reinterpret_cast< wxWindow * >(argp1);
31909 {
31910 arg2 = &temp2;
31911 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31912 }
31913 {
31914 PyThreadState* __tstate = wxPyBeginAllowThreads();
31915 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31916 wxPyEndAllowThreads(__tstate);
31917 if (PyErr_Occurred()) SWIG_fail;
31918 }
31919 resultobj = SWIG_Py_Void();
31920 return resultobj;
31921 fail:
31922 return NULL;
31923 }
31924
31925
31926 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31927 PyObject *resultobj = 0;
31928 wxWindow *arg1 = (wxWindow *) 0 ;
31929 wxSize result;
31930 void *argp1 = 0 ;
31931 int res1 = 0 ;
31932 PyObject *swig_obj[1] ;
31933
31934 if (!args) SWIG_fail;
31935 swig_obj[0] = args;
31936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31937 if (!SWIG_IsOK(res1)) {
31938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31939 }
31940 arg1 = reinterpret_cast< wxWindow * >(argp1);
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31944 wxPyEndAllowThreads(__tstate);
31945 if (PyErr_Occurred()) SWIG_fail;
31946 }
31947 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31948 return resultobj;
31949 fail:
31950 return NULL;
31951 }
31952
31953
31954 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31955 PyObject *resultobj = 0;
31956 wxWindow *arg1 = (wxWindow *) 0 ;
31957 wxSize result;
31958 void *argp1 = 0 ;
31959 int res1 = 0 ;
31960 PyObject *swig_obj[1] ;
31961
31962 if (!args) SWIG_fail;
31963 swig_obj[0] = args;
31964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31965 if (!SWIG_IsOK(res1)) {
31966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31967 }
31968 arg1 = reinterpret_cast< wxWindow * >(argp1);
31969 {
31970 PyThreadState* __tstate = wxPyBeginAllowThreads();
31971 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31972 wxPyEndAllowThreads(__tstate);
31973 if (PyErr_Occurred()) SWIG_fail;
31974 }
31975 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31976 return resultobj;
31977 fail:
31978 return NULL;
31979 }
31980
31981
31982 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31983 PyObject *resultobj = 0;
31984 wxWindow *arg1 = (wxWindow *) 0 ;
31985 int arg2 = (int) wxBOTH ;
31986 void *argp1 = 0 ;
31987 int res1 = 0 ;
31988 int val2 ;
31989 int ecode2 = 0 ;
31990 PyObject * obj0 = 0 ;
31991 PyObject * obj1 = 0 ;
31992 char * kwnames[] = {
31993 (char *) "self",(char *) "direction", NULL
31994 };
31995
31996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31998 if (!SWIG_IsOK(res1)) {
31999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
32000 }
32001 arg1 = reinterpret_cast< wxWindow * >(argp1);
32002 if (obj1) {
32003 ecode2 = SWIG_AsVal_int(obj1, &val2);
32004 if (!SWIG_IsOK(ecode2)) {
32005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
32006 }
32007 arg2 = static_cast< int >(val2);
32008 }
32009 {
32010 PyThreadState* __tstate = wxPyBeginAllowThreads();
32011 (arg1)->Center(arg2);
32012 wxPyEndAllowThreads(__tstate);
32013 if (PyErr_Occurred()) SWIG_fail;
32014 }
32015 resultobj = SWIG_Py_Void();
32016 return resultobj;
32017 fail:
32018 return NULL;
32019 }
32020
32021
32022 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32023 PyObject *resultobj = 0;
32024 wxWindow *arg1 = (wxWindow *) 0 ;
32025 int arg2 = (int) wxBOTH ;
32026 void *argp1 = 0 ;
32027 int res1 = 0 ;
32028 int val2 ;
32029 int ecode2 = 0 ;
32030 PyObject * obj0 = 0 ;
32031 PyObject * obj1 = 0 ;
32032 char * kwnames[] = {
32033 (char *) "self",(char *) "dir", NULL
32034 };
32035
32036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
32037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32038 if (!SWIG_IsOK(res1)) {
32039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
32040 }
32041 arg1 = reinterpret_cast< wxWindow * >(argp1);
32042 if (obj1) {
32043 ecode2 = SWIG_AsVal_int(obj1, &val2);
32044 if (!SWIG_IsOK(ecode2)) {
32045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
32046 }
32047 arg2 = static_cast< int >(val2);
32048 }
32049 {
32050 PyThreadState* __tstate = wxPyBeginAllowThreads();
32051 (arg1)->CenterOnParent(arg2);
32052 wxPyEndAllowThreads(__tstate);
32053 if (PyErr_Occurred()) SWIG_fail;
32054 }
32055 resultobj = SWIG_Py_Void();
32056 return resultobj;
32057 fail:
32058 return NULL;
32059 }
32060
32061
32062 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32063 PyObject *resultobj = 0;
32064 wxWindow *arg1 = (wxWindow *) 0 ;
32065 void *argp1 = 0 ;
32066 int res1 = 0 ;
32067 PyObject *swig_obj[1] ;
32068
32069 if (!args) SWIG_fail;
32070 swig_obj[0] = args;
32071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32072 if (!SWIG_IsOK(res1)) {
32073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
32074 }
32075 arg1 = reinterpret_cast< wxWindow * >(argp1);
32076 {
32077 PyThreadState* __tstate = wxPyBeginAllowThreads();
32078 (arg1)->Fit();
32079 wxPyEndAllowThreads(__tstate);
32080 if (PyErr_Occurred()) SWIG_fail;
32081 }
32082 resultobj = SWIG_Py_Void();
32083 return resultobj;
32084 fail:
32085 return NULL;
32086 }
32087
32088
32089 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32090 PyObject *resultobj = 0;
32091 wxWindow *arg1 = (wxWindow *) 0 ;
32092 void *argp1 = 0 ;
32093 int res1 = 0 ;
32094 PyObject *swig_obj[1] ;
32095
32096 if (!args) SWIG_fail;
32097 swig_obj[0] = args;
32098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32099 if (!SWIG_IsOK(res1)) {
32100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
32101 }
32102 arg1 = reinterpret_cast< wxWindow * >(argp1);
32103 {
32104 PyThreadState* __tstate = wxPyBeginAllowThreads();
32105 (arg1)->FitInside();
32106 wxPyEndAllowThreads(__tstate);
32107 if (PyErr_Occurred()) SWIG_fail;
32108 }
32109 resultobj = SWIG_Py_Void();
32110 return resultobj;
32111 fail:
32112 return NULL;
32113 }
32114
32115
32116 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32117 PyObject *resultobj = 0;
32118 wxWindow *arg1 = (wxWindow *) 0 ;
32119 int arg2 ;
32120 int arg3 ;
32121 int arg4 = (int) -1 ;
32122 int arg5 = (int) -1 ;
32123 int arg6 = (int) -1 ;
32124 int arg7 = (int) -1 ;
32125 void *argp1 = 0 ;
32126 int res1 = 0 ;
32127 int val2 ;
32128 int ecode2 = 0 ;
32129 int val3 ;
32130 int ecode3 = 0 ;
32131 int val4 ;
32132 int ecode4 = 0 ;
32133 int val5 ;
32134 int ecode5 = 0 ;
32135 int val6 ;
32136 int ecode6 = 0 ;
32137 int val7 ;
32138 int ecode7 = 0 ;
32139 PyObject * obj0 = 0 ;
32140 PyObject * obj1 = 0 ;
32141 PyObject * obj2 = 0 ;
32142 PyObject * obj3 = 0 ;
32143 PyObject * obj4 = 0 ;
32144 PyObject * obj5 = 0 ;
32145 PyObject * obj6 = 0 ;
32146 char * kwnames[] = {
32147 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
32148 };
32149
32150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32152 if (!SWIG_IsOK(res1)) {
32153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32154 }
32155 arg1 = reinterpret_cast< wxWindow * >(argp1);
32156 ecode2 = SWIG_AsVal_int(obj1, &val2);
32157 if (!SWIG_IsOK(ecode2)) {
32158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
32159 }
32160 arg2 = static_cast< int >(val2);
32161 ecode3 = SWIG_AsVal_int(obj2, &val3);
32162 if (!SWIG_IsOK(ecode3)) {
32163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
32164 }
32165 arg3 = static_cast< int >(val3);
32166 if (obj3) {
32167 ecode4 = SWIG_AsVal_int(obj3, &val4);
32168 if (!SWIG_IsOK(ecode4)) {
32169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
32170 }
32171 arg4 = static_cast< int >(val4);
32172 }
32173 if (obj4) {
32174 ecode5 = SWIG_AsVal_int(obj4, &val5);
32175 if (!SWIG_IsOK(ecode5)) {
32176 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
32177 }
32178 arg5 = static_cast< int >(val5);
32179 }
32180 if (obj5) {
32181 ecode6 = SWIG_AsVal_int(obj5, &val6);
32182 if (!SWIG_IsOK(ecode6)) {
32183 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
32184 }
32185 arg6 = static_cast< int >(val6);
32186 }
32187 if (obj6) {
32188 ecode7 = SWIG_AsVal_int(obj6, &val7);
32189 if (!SWIG_IsOK(ecode7)) {
32190 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
32191 }
32192 arg7 = static_cast< int >(val7);
32193 }
32194 {
32195 PyThreadState* __tstate = wxPyBeginAllowThreads();
32196 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
32197 wxPyEndAllowThreads(__tstate);
32198 if (PyErr_Occurred()) SWIG_fail;
32199 }
32200 resultobj = SWIG_Py_Void();
32201 return resultobj;
32202 fail:
32203 return NULL;
32204 }
32205
32206
32207 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32208 PyObject *resultobj = 0;
32209 wxWindow *arg1 = (wxWindow *) 0 ;
32210 wxSize *arg2 = 0 ;
32211 wxSize const &arg3_defvalue = wxDefaultSize ;
32212 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32213 wxSize const &arg4_defvalue = wxDefaultSize ;
32214 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32215 void *argp1 = 0 ;
32216 int res1 = 0 ;
32217 wxSize temp2 ;
32218 wxSize temp3 ;
32219 wxSize temp4 ;
32220 PyObject * obj0 = 0 ;
32221 PyObject * obj1 = 0 ;
32222 PyObject * obj2 = 0 ;
32223 PyObject * obj3 = 0 ;
32224 char * kwnames[] = {
32225 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
32226 };
32227
32228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32230 if (!SWIG_IsOK(res1)) {
32231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32232 }
32233 arg1 = reinterpret_cast< wxWindow * >(argp1);
32234 {
32235 arg2 = &temp2;
32236 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32237 }
32238 if (obj2) {
32239 {
32240 arg3 = &temp3;
32241 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32242 }
32243 }
32244 if (obj3) {
32245 {
32246 arg4 = &temp4;
32247 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32248 }
32249 }
32250 {
32251 PyThreadState* __tstate = wxPyBeginAllowThreads();
32252 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
32253 wxPyEndAllowThreads(__tstate);
32254 if (PyErr_Occurred()) SWIG_fail;
32255 }
32256 resultobj = SWIG_Py_Void();
32257 return resultobj;
32258 fail:
32259 return NULL;
32260 }
32261
32262
32263 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32264 PyObject *resultobj = 0;
32265 wxWindow *arg1 = (wxWindow *) 0 ;
32266 int arg2 ;
32267 int arg3 ;
32268 int arg4 = (int) -1 ;
32269 int arg5 = (int) -1 ;
32270 void *argp1 = 0 ;
32271 int res1 = 0 ;
32272 int val2 ;
32273 int ecode2 = 0 ;
32274 int val3 ;
32275 int ecode3 = 0 ;
32276 int val4 ;
32277 int ecode4 = 0 ;
32278 int val5 ;
32279 int ecode5 = 0 ;
32280 PyObject * obj0 = 0 ;
32281 PyObject * obj1 = 0 ;
32282 PyObject * obj2 = 0 ;
32283 PyObject * obj3 = 0 ;
32284 PyObject * obj4 = 0 ;
32285 char * kwnames[] = {
32286 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
32287 };
32288
32289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
32290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32291 if (!SWIG_IsOK(res1)) {
32292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
32293 }
32294 arg1 = reinterpret_cast< wxWindow * >(argp1);
32295 ecode2 = SWIG_AsVal_int(obj1, &val2);
32296 if (!SWIG_IsOK(ecode2)) {
32297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
32298 }
32299 arg2 = static_cast< int >(val2);
32300 ecode3 = SWIG_AsVal_int(obj2, &val3);
32301 if (!SWIG_IsOK(ecode3)) {
32302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
32303 }
32304 arg3 = static_cast< int >(val3);
32305 if (obj3) {
32306 ecode4 = SWIG_AsVal_int(obj3, &val4);
32307 if (!SWIG_IsOK(ecode4)) {
32308 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
32309 }
32310 arg4 = static_cast< int >(val4);
32311 }
32312 if (obj4) {
32313 ecode5 = SWIG_AsVal_int(obj4, &val5);
32314 if (!SWIG_IsOK(ecode5)) {
32315 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
32316 }
32317 arg5 = static_cast< int >(val5);
32318 }
32319 {
32320 PyThreadState* __tstate = wxPyBeginAllowThreads();
32321 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
32322 wxPyEndAllowThreads(__tstate);
32323 if (PyErr_Occurred()) SWIG_fail;
32324 }
32325 resultobj = SWIG_Py_Void();
32326 return resultobj;
32327 fail:
32328 return NULL;
32329 }
32330
32331
32332 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32333 PyObject *resultobj = 0;
32334 wxWindow *arg1 = (wxWindow *) 0 ;
32335 wxSize *arg2 = 0 ;
32336 wxSize const &arg3_defvalue = wxDefaultSize ;
32337 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
32338 void *argp1 = 0 ;
32339 int res1 = 0 ;
32340 wxSize temp2 ;
32341 wxSize temp3 ;
32342 PyObject * obj0 = 0 ;
32343 PyObject * obj1 = 0 ;
32344 PyObject * obj2 = 0 ;
32345 char * kwnames[] = {
32346 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
32347 };
32348
32349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32351 if (!SWIG_IsOK(res1)) {
32352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
32353 }
32354 arg1 = reinterpret_cast< wxWindow * >(argp1);
32355 {
32356 arg2 = &temp2;
32357 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32358 }
32359 if (obj2) {
32360 {
32361 arg3 = &temp3;
32362 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
32363 }
32364 }
32365 {
32366 PyThreadState* __tstate = wxPyBeginAllowThreads();
32367 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
32368 wxPyEndAllowThreads(__tstate);
32369 if (PyErr_Occurred()) SWIG_fail;
32370 }
32371 resultobj = SWIG_Py_Void();
32372 return resultobj;
32373 fail:
32374 return NULL;
32375 }
32376
32377
32378 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32379 PyObject *resultobj = 0;
32380 wxWindow *arg1 = (wxWindow *) 0 ;
32381 wxSize result;
32382 void *argp1 = 0 ;
32383 int res1 = 0 ;
32384 PyObject *swig_obj[1] ;
32385
32386 if (!args) SWIG_fail;
32387 swig_obj[0] = args;
32388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32389 if (!SWIG_IsOK(res1)) {
32390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32391 }
32392 arg1 = reinterpret_cast< wxWindow * >(argp1);
32393 {
32394 PyThreadState* __tstate = wxPyBeginAllowThreads();
32395 result = ((wxWindow const *)arg1)->GetMaxSize();
32396 wxPyEndAllowThreads(__tstate);
32397 if (PyErr_Occurred()) SWIG_fail;
32398 }
32399 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32400 return resultobj;
32401 fail:
32402 return NULL;
32403 }
32404
32405
32406 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32407 PyObject *resultobj = 0;
32408 wxWindow *arg1 = (wxWindow *) 0 ;
32409 wxSize result;
32410 void *argp1 = 0 ;
32411 int res1 = 0 ;
32412 PyObject *swig_obj[1] ;
32413
32414 if (!args) SWIG_fail;
32415 swig_obj[0] = args;
32416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32417 if (!SWIG_IsOK(res1)) {
32418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32419 }
32420 arg1 = reinterpret_cast< wxWindow * >(argp1);
32421 {
32422 PyThreadState* __tstate = wxPyBeginAllowThreads();
32423 result = ((wxWindow const *)arg1)->GetMinSize();
32424 wxPyEndAllowThreads(__tstate);
32425 if (PyErr_Occurred()) SWIG_fail;
32426 }
32427 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32428 return resultobj;
32429 fail:
32430 return NULL;
32431 }
32432
32433
32434 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32435 PyObject *resultobj = 0;
32436 wxWindow *arg1 = (wxWindow *) 0 ;
32437 wxSize *arg2 = 0 ;
32438 void *argp1 = 0 ;
32439 int res1 = 0 ;
32440 wxSize temp2 ;
32441 PyObject * obj0 = 0 ;
32442 PyObject * obj1 = 0 ;
32443 char * kwnames[] = {
32444 (char *) "self",(char *) "minSize", NULL
32445 };
32446
32447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
32448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32449 if (!SWIG_IsOK(res1)) {
32450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32451 }
32452 arg1 = reinterpret_cast< wxWindow * >(argp1);
32453 {
32454 arg2 = &temp2;
32455 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32456 }
32457 {
32458 PyThreadState* __tstate = wxPyBeginAllowThreads();
32459 (arg1)->SetMinSize((wxSize const &)*arg2);
32460 wxPyEndAllowThreads(__tstate);
32461 if (PyErr_Occurred()) SWIG_fail;
32462 }
32463 resultobj = SWIG_Py_Void();
32464 return resultobj;
32465 fail:
32466 return NULL;
32467 }
32468
32469
32470 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32471 PyObject *resultobj = 0;
32472 wxWindow *arg1 = (wxWindow *) 0 ;
32473 wxSize *arg2 = 0 ;
32474 void *argp1 = 0 ;
32475 int res1 = 0 ;
32476 wxSize temp2 ;
32477 PyObject * obj0 = 0 ;
32478 PyObject * obj1 = 0 ;
32479 char * kwnames[] = {
32480 (char *) "self",(char *) "maxSize", NULL
32481 };
32482
32483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
32484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32485 if (!SWIG_IsOK(res1)) {
32486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32487 }
32488 arg1 = reinterpret_cast< wxWindow * >(argp1);
32489 {
32490 arg2 = &temp2;
32491 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32492 }
32493 {
32494 PyThreadState* __tstate = wxPyBeginAllowThreads();
32495 (arg1)->SetMaxSize((wxSize const &)*arg2);
32496 wxPyEndAllowThreads(__tstate);
32497 if (PyErr_Occurred()) SWIG_fail;
32498 }
32499 resultobj = SWIG_Py_Void();
32500 return resultobj;
32501 fail:
32502 return NULL;
32503 }
32504
32505
32506 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32507 PyObject *resultobj = 0;
32508 wxWindow *arg1 = (wxWindow *) 0 ;
32509 int result;
32510 void *argp1 = 0 ;
32511 int res1 = 0 ;
32512 PyObject *swig_obj[1] ;
32513
32514 if (!args) SWIG_fail;
32515 swig_obj[0] = args;
32516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32517 if (!SWIG_IsOK(res1)) {
32518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32519 }
32520 arg1 = reinterpret_cast< wxWindow * >(argp1);
32521 {
32522 PyThreadState* __tstate = wxPyBeginAllowThreads();
32523 result = (int)((wxWindow const *)arg1)->GetMinWidth();
32524 wxPyEndAllowThreads(__tstate);
32525 if (PyErr_Occurred()) SWIG_fail;
32526 }
32527 resultobj = SWIG_From_int(static_cast< int >(result));
32528 return resultobj;
32529 fail:
32530 return NULL;
32531 }
32532
32533
32534 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32535 PyObject *resultobj = 0;
32536 wxWindow *arg1 = (wxWindow *) 0 ;
32537 int result;
32538 void *argp1 = 0 ;
32539 int res1 = 0 ;
32540 PyObject *swig_obj[1] ;
32541
32542 if (!args) SWIG_fail;
32543 swig_obj[0] = args;
32544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32545 if (!SWIG_IsOK(res1)) {
32546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32547 }
32548 arg1 = reinterpret_cast< wxWindow * >(argp1);
32549 {
32550 PyThreadState* __tstate = wxPyBeginAllowThreads();
32551 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32552 wxPyEndAllowThreads(__tstate);
32553 if (PyErr_Occurred()) SWIG_fail;
32554 }
32555 resultobj = SWIG_From_int(static_cast< int >(result));
32556 return resultobj;
32557 fail:
32558 return NULL;
32559 }
32560
32561
32562 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32563 PyObject *resultobj = 0;
32564 wxWindow *arg1 = (wxWindow *) 0 ;
32565 int result;
32566 void *argp1 = 0 ;
32567 int res1 = 0 ;
32568 PyObject *swig_obj[1] ;
32569
32570 if (!args) SWIG_fail;
32571 swig_obj[0] = args;
32572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32573 if (!SWIG_IsOK(res1)) {
32574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32575 }
32576 arg1 = reinterpret_cast< wxWindow * >(argp1);
32577 {
32578 PyThreadState* __tstate = wxPyBeginAllowThreads();
32579 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32580 wxPyEndAllowThreads(__tstate);
32581 if (PyErr_Occurred()) SWIG_fail;
32582 }
32583 resultobj = SWIG_From_int(static_cast< int >(result));
32584 return resultobj;
32585 fail:
32586 return NULL;
32587 }
32588
32589
32590 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32591 PyObject *resultobj = 0;
32592 wxWindow *arg1 = (wxWindow *) 0 ;
32593 int result;
32594 void *argp1 = 0 ;
32595 int res1 = 0 ;
32596 PyObject *swig_obj[1] ;
32597
32598 if (!args) SWIG_fail;
32599 swig_obj[0] = args;
32600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32601 if (!SWIG_IsOK(res1)) {
32602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32603 }
32604 arg1 = reinterpret_cast< wxWindow * >(argp1);
32605 {
32606 PyThreadState* __tstate = wxPyBeginAllowThreads();
32607 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32608 wxPyEndAllowThreads(__tstate);
32609 if (PyErr_Occurred()) SWIG_fail;
32610 }
32611 resultobj = SWIG_From_int(static_cast< int >(result));
32612 return resultobj;
32613 fail:
32614 return NULL;
32615 }
32616
32617
32618 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32619 PyObject *resultobj = 0;
32620 wxWindow *arg1 = (wxWindow *) 0 ;
32621 wxSize *arg2 = 0 ;
32622 void *argp1 = 0 ;
32623 int res1 = 0 ;
32624 wxSize temp2 ;
32625 PyObject * obj0 = 0 ;
32626 PyObject * obj1 = 0 ;
32627 char * kwnames[] = {
32628 (char *) "self",(char *) "size", NULL
32629 };
32630
32631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32633 if (!SWIG_IsOK(res1)) {
32634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32635 }
32636 arg1 = reinterpret_cast< wxWindow * >(argp1);
32637 {
32638 arg2 = &temp2;
32639 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32640 }
32641 {
32642 PyThreadState* __tstate = wxPyBeginAllowThreads();
32643 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32644 wxPyEndAllowThreads(__tstate);
32645 if (PyErr_Occurred()) SWIG_fail;
32646 }
32647 resultobj = SWIG_Py_Void();
32648 return resultobj;
32649 fail:
32650 return NULL;
32651 }
32652
32653
32654 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32655 PyObject *resultobj = 0;
32656 wxWindow *arg1 = (wxWindow *) 0 ;
32657 int arg2 ;
32658 int arg3 ;
32659 void *argp1 = 0 ;
32660 int res1 = 0 ;
32661 int val2 ;
32662 int ecode2 = 0 ;
32663 int val3 ;
32664 int ecode3 = 0 ;
32665 PyObject * obj0 = 0 ;
32666 PyObject * obj1 = 0 ;
32667 PyObject * obj2 = 0 ;
32668 char * kwnames[] = {
32669 (char *) "self",(char *) "w",(char *) "h", NULL
32670 };
32671
32672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32674 if (!SWIG_IsOK(res1)) {
32675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32676 }
32677 arg1 = reinterpret_cast< wxWindow * >(argp1);
32678 ecode2 = SWIG_AsVal_int(obj1, &val2);
32679 if (!SWIG_IsOK(ecode2)) {
32680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32681 }
32682 arg2 = static_cast< int >(val2);
32683 ecode3 = SWIG_AsVal_int(obj2, &val3);
32684 if (!SWIG_IsOK(ecode3)) {
32685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32686 }
32687 arg3 = static_cast< int >(val3);
32688 {
32689 PyThreadState* __tstate = wxPyBeginAllowThreads();
32690 (arg1)->SetVirtualSize(arg2,arg3);
32691 wxPyEndAllowThreads(__tstate);
32692 if (PyErr_Occurred()) SWIG_fail;
32693 }
32694 resultobj = SWIG_Py_Void();
32695 return resultobj;
32696 fail:
32697 return NULL;
32698 }
32699
32700
32701 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32702 PyObject *resultobj = 0;
32703 wxWindow *arg1 = (wxWindow *) 0 ;
32704 wxSize result;
32705 void *argp1 = 0 ;
32706 int res1 = 0 ;
32707 PyObject *swig_obj[1] ;
32708
32709 if (!args) SWIG_fail;
32710 swig_obj[0] = args;
32711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32712 if (!SWIG_IsOK(res1)) {
32713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32714 }
32715 arg1 = reinterpret_cast< wxWindow * >(argp1);
32716 {
32717 PyThreadState* __tstate = wxPyBeginAllowThreads();
32718 result = ((wxWindow const *)arg1)->GetVirtualSize();
32719 wxPyEndAllowThreads(__tstate);
32720 if (PyErr_Occurred()) SWIG_fail;
32721 }
32722 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32723 return resultobj;
32724 fail:
32725 return NULL;
32726 }
32727
32728
32729 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32730 PyObject *resultobj = 0;
32731 wxWindow *arg1 = (wxWindow *) 0 ;
32732 int *arg2 = (int *) 0 ;
32733 int *arg3 = (int *) 0 ;
32734 void *argp1 = 0 ;
32735 int res1 = 0 ;
32736 int temp2 ;
32737 int res2 = SWIG_TMPOBJ ;
32738 int temp3 ;
32739 int res3 = SWIG_TMPOBJ ;
32740 PyObject *swig_obj[1] ;
32741
32742 arg2 = &temp2;
32743 arg3 = &temp3;
32744 if (!args) SWIG_fail;
32745 swig_obj[0] = args;
32746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32747 if (!SWIG_IsOK(res1)) {
32748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32749 }
32750 arg1 = reinterpret_cast< wxWindow * >(argp1);
32751 {
32752 PyThreadState* __tstate = wxPyBeginAllowThreads();
32753 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32754 wxPyEndAllowThreads(__tstate);
32755 if (PyErr_Occurred()) SWIG_fail;
32756 }
32757 resultobj = SWIG_Py_Void();
32758 if (SWIG_IsTmpObj(res2)) {
32759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32760 } else {
32761 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32762 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32763 }
32764 if (SWIG_IsTmpObj(res3)) {
32765 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32766 } else {
32767 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32768 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32769 }
32770 return resultobj;
32771 fail:
32772 return NULL;
32773 }
32774
32775
32776 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32777 PyObject *resultobj = 0;
32778 wxWindow *arg1 = (wxWindow *) 0 ;
32779 wxSize result;
32780 void *argp1 = 0 ;
32781 int res1 = 0 ;
32782 PyObject *swig_obj[1] ;
32783
32784 if (!args) SWIG_fail;
32785 swig_obj[0] = args;
32786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32787 if (!SWIG_IsOK(res1)) {
32788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32789 }
32790 arg1 = reinterpret_cast< wxWindow * >(argp1);
32791 {
32792 PyThreadState* __tstate = wxPyBeginAllowThreads();
32793 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32794 wxPyEndAllowThreads(__tstate);
32795 if (PyErr_Occurred()) SWIG_fail;
32796 }
32797 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32798 return resultobj;
32799 fail:
32800 return NULL;
32801 }
32802
32803
32804 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32805 PyObject *resultobj = 0;
32806 wxWindow *arg1 = (wxWindow *) 0 ;
32807 bool arg2 = (bool) true ;
32808 bool result;
32809 void *argp1 = 0 ;
32810 int res1 = 0 ;
32811 bool val2 ;
32812 int ecode2 = 0 ;
32813 PyObject * obj0 = 0 ;
32814 PyObject * obj1 = 0 ;
32815 char * kwnames[] = {
32816 (char *) "self",(char *) "show", NULL
32817 };
32818
32819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32821 if (!SWIG_IsOK(res1)) {
32822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32823 }
32824 arg1 = reinterpret_cast< wxWindow * >(argp1);
32825 if (obj1) {
32826 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32827 if (!SWIG_IsOK(ecode2)) {
32828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32829 }
32830 arg2 = static_cast< bool >(val2);
32831 }
32832 {
32833 PyThreadState* __tstate = wxPyBeginAllowThreads();
32834 result = (bool)(arg1)->Show(arg2);
32835 wxPyEndAllowThreads(__tstate);
32836 if (PyErr_Occurred()) SWIG_fail;
32837 }
32838 {
32839 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32840 }
32841 return resultobj;
32842 fail:
32843 return NULL;
32844 }
32845
32846
32847 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32848 PyObject *resultobj = 0;
32849 wxWindow *arg1 = (wxWindow *) 0 ;
32850 bool result;
32851 void *argp1 = 0 ;
32852 int res1 = 0 ;
32853 PyObject *swig_obj[1] ;
32854
32855 if (!args) SWIG_fail;
32856 swig_obj[0] = args;
32857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32858 if (!SWIG_IsOK(res1)) {
32859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32860 }
32861 arg1 = reinterpret_cast< wxWindow * >(argp1);
32862 {
32863 PyThreadState* __tstate = wxPyBeginAllowThreads();
32864 result = (bool)(arg1)->Hide();
32865 wxPyEndAllowThreads(__tstate);
32866 if (PyErr_Occurred()) SWIG_fail;
32867 }
32868 {
32869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32870 }
32871 return resultobj;
32872 fail:
32873 return NULL;
32874 }
32875
32876
32877 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32878 PyObject *resultobj = 0;
32879 wxWindow *arg1 = (wxWindow *) 0 ;
32880 bool arg2 = (bool) true ;
32881 bool result;
32882 void *argp1 = 0 ;
32883 int res1 = 0 ;
32884 bool val2 ;
32885 int ecode2 = 0 ;
32886 PyObject * obj0 = 0 ;
32887 PyObject * obj1 = 0 ;
32888 char * kwnames[] = {
32889 (char *) "self",(char *) "enable", NULL
32890 };
32891
32892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32894 if (!SWIG_IsOK(res1)) {
32895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32896 }
32897 arg1 = reinterpret_cast< wxWindow * >(argp1);
32898 if (obj1) {
32899 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32900 if (!SWIG_IsOK(ecode2)) {
32901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32902 }
32903 arg2 = static_cast< bool >(val2);
32904 }
32905 {
32906 PyThreadState* __tstate = wxPyBeginAllowThreads();
32907 result = (bool)(arg1)->Enable(arg2);
32908 wxPyEndAllowThreads(__tstate);
32909 if (PyErr_Occurred()) SWIG_fail;
32910 }
32911 {
32912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32913 }
32914 return resultobj;
32915 fail:
32916 return NULL;
32917 }
32918
32919
32920 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32921 PyObject *resultobj = 0;
32922 wxWindow *arg1 = (wxWindow *) 0 ;
32923 bool result;
32924 void *argp1 = 0 ;
32925 int res1 = 0 ;
32926 PyObject *swig_obj[1] ;
32927
32928 if (!args) SWIG_fail;
32929 swig_obj[0] = args;
32930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32931 if (!SWIG_IsOK(res1)) {
32932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32933 }
32934 arg1 = reinterpret_cast< wxWindow * >(argp1);
32935 {
32936 PyThreadState* __tstate = wxPyBeginAllowThreads();
32937 result = (bool)(arg1)->Disable();
32938 wxPyEndAllowThreads(__tstate);
32939 if (PyErr_Occurred()) SWIG_fail;
32940 }
32941 {
32942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32943 }
32944 return resultobj;
32945 fail:
32946 return NULL;
32947 }
32948
32949
32950 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32951 PyObject *resultobj = 0;
32952 wxWindow *arg1 = (wxWindow *) 0 ;
32953 bool result;
32954 void *argp1 = 0 ;
32955 int res1 = 0 ;
32956 PyObject *swig_obj[1] ;
32957
32958 if (!args) SWIG_fail;
32959 swig_obj[0] = args;
32960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32961 if (!SWIG_IsOK(res1)) {
32962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32963 }
32964 arg1 = reinterpret_cast< wxWindow * >(argp1);
32965 {
32966 PyThreadState* __tstate = wxPyBeginAllowThreads();
32967 result = (bool)((wxWindow const *)arg1)->IsShown();
32968 wxPyEndAllowThreads(__tstate);
32969 if (PyErr_Occurred()) SWIG_fail;
32970 }
32971 {
32972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32973 }
32974 return resultobj;
32975 fail:
32976 return NULL;
32977 }
32978
32979
32980 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32981 PyObject *resultobj = 0;
32982 wxWindow *arg1 = (wxWindow *) 0 ;
32983 bool result;
32984 void *argp1 = 0 ;
32985 int res1 = 0 ;
32986 PyObject *swig_obj[1] ;
32987
32988 if (!args) SWIG_fail;
32989 swig_obj[0] = args;
32990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32991 if (!SWIG_IsOK(res1)) {
32992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32993 }
32994 arg1 = reinterpret_cast< wxWindow * >(argp1);
32995 {
32996 PyThreadState* __tstate = wxPyBeginAllowThreads();
32997 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32998 wxPyEndAllowThreads(__tstate);
32999 if (PyErr_Occurred()) SWIG_fail;
33000 }
33001 {
33002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33003 }
33004 return resultobj;
33005 fail:
33006 return NULL;
33007 }
33008
33009
33010 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33011 PyObject *resultobj = 0;
33012 wxWindow *arg1 = (wxWindow *) 0 ;
33013 long arg2 ;
33014 void *argp1 = 0 ;
33015 int res1 = 0 ;
33016 long val2 ;
33017 int ecode2 = 0 ;
33018 PyObject * obj0 = 0 ;
33019 PyObject * obj1 = 0 ;
33020 char * kwnames[] = {
33021 (char *) "self",(char *) "style", NULL
33022 };
33023
33024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33026 if (!SWIG_IsOK(res1)) {
33027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33028 }
33029 arg1 = reinterpret_cast< wxWindow * >(argp1);
33030 ecode2 = SWIG_AsVal_long(obj1, &val2);
33031 if (!SWIG_IsOK(ecode2)) {
33032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33033 }
33034 arg2 = static_cast< long >(val2);
33035 {
33036 PyThreadState* __tstate = wxPyBeginAllowThreads();
33037 (arg1)->SetWindowStyleFlag(arg2);
33038 wxPyEndAllowThreads(__tstate);
33039 if (PyErr_Occurred()) SWIG_fail;
33040 }
33041 resultobj = SWIG_Py_Void();
33042 return resultobj;
33043 fail:
33044 return NULL;
33045 }
33046
33047
33048 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33049 PyObject *resultobj = 0;
33050 wxWindow *arg1 = (wxWindow *) 0 ;
33051 long result;
33052 void *argp1 = 0 ;
33053 int res1 = 0 ;
33054 PyObject *swig_obj[1] ;
33055
33056 if (!args) SWIG_fail;
33057 swig_obj[0] = args;
33058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33059 if (!SWIG_IsOK(res1)) {
33060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33061 }
33062 arg1 = reinterpret_cast< wxWindow * >(argp1);
33063 {
33064 PyThreadState* __tstate = wxPyBeginAllowThreads();
33065 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33066 wxPyEndAllowThreads(__tstate);
33067 if (PyErr_Occurred()) SWIG_fail;
33068 }
33069 resultobj = SWIG_From_long(static_cast< long >(result));
33070 return resultobj;
33071 fail:
33072 return NULL;
33073 }
33074
33075
33076 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33077 PyObject *resultobj = 0;
33078 wxWindow *arg1 = (wxWindow *) 0 ;
33079 int arg2 ;
33080 bool result;
33081 void *argp1 = 0 ;
33082 int res1 = 0 ;
33083 int val2 ;
33084 int ecode2 = 0 ;
33085 PyObject * obj0 = 0 ;
33086 PyObject * obj1 = 0 ;
33087 char * kwnames[] = {
33088 (char *) "self",(char *) "flag", NULL
33089 };
33090
33091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33093 if (!SWIG_IsOK(res1)) {
33094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33095 }
33096 arg1 = reinterpret_cast< wxWindow * >(argp1);
33097 ecode2 = SWIG_AsVal_int(obj1, &val2);
33098 if (!SWIG_IsOK(ecode2)) {
33099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33100 }
33101 arg2 = static_cast< int >(val2);
33102 {
33103 PyThreadState* __tstate = wxPyBeginAllowThreads();
33104 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
33105 wxPyEndAllowThreads(__tstate);
33106 if (PyErr_Occurred()) SWIG_fail;
33107 }
33108 {
33109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33110 }
33111 return resultobj;
33112 fail:
33113 return NULL;
33114 }
33115
33116
33117 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33118 PyObject *resultobj = 0;
33119 wxWindow *arg1 = (wxWindow *) 0 ;
33120 bool result;
33121 void *argp1 = 0 ;
33122 int res1 = 0 ;
33123 PyObject *swig_obj[1] ;
33124
33125 if (!args) SWIG_fail;
33126 swig_obj[0] = args;
33127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33128 if (!SWIG_IsOK(res1)) {
33129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33130 }
33131 arg1 = reinterpret_cast< wxWindow * >(argp1);
33132 {
33133 PyThreadState* __tstate = wxPyBeginAllowThreads();
33134 result = (bool)((wxWindow const *)arg1)->IsRetained();
33135 wxPyEndAllowThreads(__tstate);
33136 if (PyErr_Occurred()) SWIG_fail;
33137 }
33138 {
33139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33140 }
33141 return resultobj;
33142 fail:
33143 return NULL;
33144 }
33145
33146
33147 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33148 PyObject *resultobj = 0;
33149 wxWindow *arg1 = (wxWindow *) 0 ;
33150 long arg2 ;
33151 void *argp1 = 0 ;
33152 int res1 = 0 ;
33153 long val2 ;
33154 int ecode2 = 0 ;
33155 PyObject * obj0 = 0 ;
33156 PyObject * obj1 = 0 ;
33157 char * kwnames[] = {
33158 (char *) "self",(char *) "exStyle", NULL
33159 };
33160
33161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33163 if (!SWIG_IsOK(res1)) {
33164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33165 }
33166 arg1 = reinterpret_cast< wxWindow * >(argp1);
33167 ecode2 = SWIG_AsVal_long(obj1, &val2);
33168 if (!SWIG_IsOK(ecode2)) {
33169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33170 }
33171 arg2 = static_cast< long >(val2);
33172 {
33173 PyThreadState* __tstate = wxPyBeginAllowThreads();
33174 (arg1)->SetExtraStyle(arg2);
33175 wxPyEndAllowThreads(__tstate);
33176 if (PyErr_Occurred()) SWIG_fail;
33177 }
33178 resultobj = SWIG_Py_Void();
33179 return resultobj;
33180 fail:
33181 return NULL;
33182 }
33183
33184
33185 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33186 PyObject *resultobj = 0;
33187 wxWindow *arg1 = (wxWindow *) 0 ;
33188 long result;
33189 void *argp1 = 0 ;
33190 int res1 = 0 ;
33191 PyObject *swig_obj[1] ;
33192
33193 if (!args) SWIG_fail;
33194 swig_obj[0] = args;
33195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33196 if (!SWIG_IsOK(res1)) {
33197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33198 }
33199 arg1 = reinterpret_cast< wxWindow * >(argp1);
33200 {
33201 PyThreadState* __tstate = wxPyBeginAllowThreads();
33202 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33203 wxPyEndAllowThreads(__tstate);
33204 if (PyErr_Occurred()) SWIG_fail;
33205 }
33206 resultobj = SWIG_From_long(static_cast< long >(result));
33207 return resultobj;
33208 fail:
33209 return NULL;
33210 }
33211
33212
33213 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33214 PyObject *resultobj = 0;
33215 wxWindow *arg1 = (wxWindow *) 0 ;
33216 bool arg2 = (bool) true ;
33217 void *argp1 = 0 ;
33218 int res1 = 0 ;
33219 bool val2 ;
33220 int ecode2 = 0 ;
33221 PyObject * obj0 = 0 ;
33222 PyObject * obj1 = 0 ;
33223 char * kwnames[] = {
33224 (char *) "self",(char *) "modal", NULL
33225 };
33226
33227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33229 if (!SWIG_IsOK(res1)) {
33230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33231 }
33232 arg1 = reinterpret_cast< wxWindow * >(argp1);
33233 if (obj1) {
33234 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33235 if (!SWIG_IsOK(ecode2)) {
33236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33237 }
33238 arg2 = static_cast< bool >(val2);
33239 }
33240 {
33241 PyThreadState* __tstate = wxPyBeginAllowThreads();
33242 (arg1)->MakeModal(arg2);
33243 wxPyEndAllowThreads(__tstate);
33244 if (PyErr_Occurred()) SWIG_fail;
33245 }
33246 resultobj = SWIG_Py_Void();
33247 return resultobj;
33248 fail:
33249 return NULL;
33250 }
33251
33252
33253 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33254 PyObject *resultobj = 0;
33255 wxWindow *arg1 = (wxWindow *) 0 ;
33256 bool arg2 ;
33257 void *argp1 = 0 ;
33258 int res1 = 0 ;
33259 bool val2 ;
33260 int ecode2 = 0 ;
33261 PyObject * obj0 = 0 ;
33262 PyObject * obj1 = 0 ;
33263 char * kwnames[] = {
33264 (char *) "self",(char *) "enableTheme", NULL
33265 };
33266
33267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33269 if (!SWIG_IsOK(res1)) {
33270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33271 }
33272 arg1 = reinterpret_cast< wxWindow * >(argp1);
33273 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33274 if (!SWIG_IsOK(ecode2)) {
33275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33276 }
33277 arg2 = static_cast< bool >(val2);
33278 {
33279 PyThreadState* __tstate = wxPyBeginAllowThreads();
33280 (arg1)->SetThemeEnabled(arg2);
33281 wxPyEndAllowThreads(__tstate);
33282 if (PyErr_Occurred()) SWIG_fail;
33283 }
33284 resultobj = SWIG_Py_Void();
33285 return resultobj;
33286 fail:
33287 return NULL;
33288 }
33289
33290
33291 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33292 PyObject *resultobj = 0;
33293 wxWindow *arg1 = (wxWindow *) 0 ;
33294 bool result;
33295 void *argp1 = 0 ;
33296 int res1 = 0 ;
33297 PyObject *swig_obj[1] ;
33298
33299 if (!args) SWIG_fail;
33300 swig_obj[0] = args;
33301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33302 if (!SWIG_IsOK(res1)) {
33303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33304 }
33305 arg1 = reinterpret_cast< wxWindow * >(argp1);
33306 {
33307 PyThreadState* __tstate = wxPyBeginAllowThreads();
33308 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33309 wxPyEndAllowThreads(__tstate);
33310 if (PyErr_Occurred()) SWIG_fail;
33311 }
33312 {
33313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33314 }
33315 return resultobj;
33316 fail:
33317 return NULL;
33318 }
33319
33320
33321 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33322 PyObject *resultobj = 0;
33323 wxWindow *arg1 = (wxWindow *) 0 ;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 PyObject *swig_obj[1] ;
33327
33328 if (!args) SWIG_fail;
33329 swig_obj[0] = args;
33330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33331 if (!SWIG_IsOK(res1)) {
33332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33333 }
33334 arg1 = reinterpret_cast< wxWindow * >(argp1);
33335 {
33336 PyThreadState* __tstate = wxPyBeginAllowThreads();
33337 (arg1)->SetFocus();
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 resultobj = SWIG_Py_Void();
33342 return resultobj;
33343 fail:
33344 return NULL;
33345 }
33346
33347
33348 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33349 PyObject *resultobj = 0;
33350 wxWindow *arg1 = (wxWindow *) 0 ;
33351 void *argp1 = 0 ;
33352 int res1 = 0 ;
33353 PyObject *swig_obj[1] ;
33354
33355 if (!args) SWIG_fail;
33356 swig_obj[0] = args;
33357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33358 if (!SWIG_IsOK(res1)) {
33359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33360 }
33361 arg1 = reinterpret_cast< wxWindow * >(argp1);
33362 {
33363 PyThreadState* __tstate = wxPyBeginAllowThreads();
33364 (arg1)->SetFocusFromKbd();
33365 wxPyEndAllowThreads(__tstate);
33366 if (PyErr_Occurred()) SWIG_fail;
33367 }
33368 resultobj = SWIG_Py_Void();
33369 return resultobj;
33370 fail:
33371 return NULL;
33372 }
33373
33374
33375 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33376 PyObject *resultobj = 0;
33377 wxWindow *result = 0 ;
33378
33379 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33380 {
33381 if (!wxPyCheckForApp()) SWIG_fail;
33382 PyThreadState* __tstate = wxPyBeginAllowThreads();
33383 result = (wxWindow *)wxWindow::FindFocus();
33384 wxPyEndAllowThreads(__tstate);
33385 if (PyErr_Occurred()) SWIG_fail;
33386 }
33387 {
33388 resultobj = wxPyMake_wxObject(result, 0);
33389 }
33390 return resultobj;
33391 fail:
33392 return NULL;
33393 }
33394
33395
33396 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33397 PyObject *resultobj = 0;
33398 wxWindow *arg1 = (wxWindow *) 0 ;
33399 bool result;
33400 void *argp1 = 0 ;
33401 int res1 = 0 ;
33402 PyObject *swig_obj[1] ;
33403
33404 if (!args) SWIG_fail;
33405 swig_obj[0] = args;
33406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33407 if (!SWIG_IsOK(res1)) {
33408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
33409 }
33410 arg1 = reinterpret_cast< wxWindow * >(argp1);
33411 {
33412 PyThreadState* __tstate = wxPyBeginAllowThreads();
33413 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
33414 wxPyEndAllowThreads(__tstate);
33415 if (PyErr_Occurred()) SWIG_fail;
33416 }
33417 {
33418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33419 }
33420 return resultobj;
33421 fail:
33422 return NULL;
33423 }
33424
33425
33426 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33427 PyObject *resultobj = 0;
33428 wxWindow *arg1 = (wxWindow *) 0 ;
33429 bool result;
33430 void *argp1 = 0 ;
33431 int res1 = 0 ;
33432 PyObject *swig_obj[1] ;
33433
33434 if (!args) SWIG_fail;
33435 swig_obj[0] = args;
33436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33437 if (!SWIG_IsOK(res1)) {
33438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33439 }
33440 arg1 = reinterpret_cast< wxWindow * >(argp1);
33441 {
33442 PyThreadState* __tstate = wxPyBeginAllowThreads();
33443 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33444 wxPyEndAllowThreads(__tstate);
33445 if (PyErr_Occurred()) SWIG_fail;
33446 }
33447 {
33448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33449 }
33450 return resultobj;
33451 fail:
33452 return NULL;
33453 }
33454
33455
33456 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33457 PyObject *resultobj = 0;
33458 wxWindow *arg1 = (wxWindow *) 0 ;
33459 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33460 bool result;
33461 void *argp1 = 0 ;
33462 int res1 = 0 ;
33463 int val2 ;
33464 int ecode2 = 0 ;
33465 PyObject * obj0 = 0 ;
33466 PyObject * obj1 = 0 ;
33467 char * kwnames[] = {
33468 (char *) "self",(char *) "flags", NULL
33469 };
33470
33471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33473 if (!SWIG_IsOK(res1)) {
33474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33475 }
33476 arg1 = reinterpret_cast< wxWindow * >(argp1);
33477 if (obj1) {
33478 ecode2 = SWIG_AsVal_int(obj1, &val2);
33479 if (!SWIG_IsOK(ecode2)) {
33480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33481 }
33482 arg2 = static_cast< int >(val2);
33483 }
33484 {
33485 PyThreadState* __tstate = wxPyBeginAllowThreads();
33486 result = (bool)(arg1)->Navigate(arg2);
33487 wxPyEndAllowThreads(__tstate);
33488 if (PyErr_Occurred()) SWIG_fail;
33489 }
33490 {
33491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33492 }
33493 return resultobj;
33494 fail:
33495 return NULL;
33496 }
33497
33498
33499 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33500 PyObject *resultobj = 0;
33501 wxWindow *arg1 = (wxWindow *) 0 ;
33502 wxWindow *arg2 = (wxWindow *) 0 ;
33503 void *argp1 = 0 ;
33504 int res1 = 0 ;
33505 void *argp2 = 0 ;
33506 int res2 = 0 ;
33507 PyObject * obj0 = 0 ;
33508 PyObject * obj1 = 0 ;
33509 char * kwnames[] = {
33510 (char *) "self",(char *) "win", NULL
33511 };
33512
33513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33515 if (!SWIG_IsOK(res1)) {
33516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33517 }
33518 arg1 = reinterpret_cast< wxWindow * >(argp1);
33519 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33520 if (!SWIG_IsOK(res2)) {
33521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33522 }
33523 arg2 = reinterpret_cast< wxWindow * >(argp2);
33524 {
33525 PyThreadState* __tstate = wxPyBeginAllowThreads();
33526 (arg1)->MoveAfterInTabOrder(arg2);
33527 wxPyEndAllowThreads(__tstate);
33528 if (PyErr_Occurred()) SWIG_fail;
33529 }
33530 resultobj = SWIG_Py_Void();
33531 return resultobj;
33532 fail:
33533 return NULL;
33534 }
33535
33536
33537 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33538 PyObject *resultobj = 0;
33539 wxWindow *arg1 = (wxWindow *) 0 ;
33540 wxWindow *arg2 = (wxWindow *) 0 ;
33541 void *argp1 = 0 ;
33542 int res1 = 0 ;
33543 void *argp2 = 0 ;
33544 int res2 = 0 ;
33545 PyObject * obj0 = 0 ;
33546 PyObject * obj1 = 0 ;
33547 char * kwnames[] = {
33548 (char *) "self",(char *) "win", NULL
33549 };
33550
33551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33553 if (!SWIG_IsOK(res1)) {
33554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33555 }
33556 arg1 = reinterpret_cast< wxWindow * >(argp1);
33557 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33558 if (!SWIG_IsOK(res2)) {
33559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33560 }
33561 arg2 = reinterpret_cast< wxWindow * >(argp2);
33562 {
33563 PyThreadState* __tstate = wxPyBeginAllowThreads();
33564 (arg1)->MoveBeforeInTabOrder(arg2);
33565 wxPyEndAllowThreads(__tstate);
33566 if (PyErr_Occurred()) SWIG_fail;
33567 }
33568 resultobj = SWIG_Py_Void();
33569 return resultobj;
33570 fail:
33571 return NULL;
33572 }
33573
33574
33575 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33576 PyObject *resultobj = 0;
33577 wxWindow *arg1 = (wxWindow *) 0 ;
33578 PyObject *result = 0 ;
33579 void *argp1 = 0 ;
33580 int res1 = 0 ;
33581 PyObject *swig_obj[1] ;
33582
33583 if (!args) SWIG_fail;
33584 swig_obj[0] = args;
33585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33586 if (!SWIG_IsOK(res1)) {
33587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33588 }
33589 arg1 = reinterpret_cast< wxWindow * >(argp1);
33590 {
33591 PyThreadState* __tstate = wxPyBeginAllowThreads();
33592 result = (PyObject *)wxWindow_GetChildren(arg1);
33593 wxPyEndAllowThreads(__tstate);
33594 if (PyErr_Occurred()) SWIG_fail;
33595 }
33596 resultobj = result;
33597 return resultobj;
33598 fail:
33599 return NULL;
33600 }
33601
33602
33603 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33604 PyObject *resultobj = 0;
33605 wxWindow *arg1 = (wxWindow *) 0 ;
33606 wxWindow *result = 0 ;
33607 void *argp1 = 0 ;
33608 int res1 = 0 ;
33609 PyObject *swig_obj[1] ;
33610
33611 if (!args) SWIG_fail;
33612 swig_obj[0] = args;
33613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33614 if (!SWIG_IsOK(res1)) {
33615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33616 }
33617 arg1 = reinterpret_cast< wxWindow * >(argp1);
33618 {
33619 PyThreadState* __tstate = wxPyBeginAllowThreads();
33620 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33621 wxPyEndAllowThreads(__tstate);
33622 if (PyErr_Occurred()) SWIG_fail;
33623 }
33624 {
33625 resultobj = wxPyMake_wxObject(result, 0);
33626 }
33627 return resultobj;
33628 fail:
33629 return NULL;
33630 }
33631
33632
33633 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33634 PyObject *resultobj = 0;
33635 wxWindow *arg1 = (wxWindow *) 0 ;
33636 wxWindow *result = 0 ;
33637 void *argp1 = 0 ;
33638 int res1 = 0 ;
33639 PyObject *swig_obj[1] ;
33640
33641 if (!args) SWIG_fail;
33642 swig_obj[0] = args;
33643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33644 if (!SWIG_IsOK(res1)) {
33645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33646 }
33647 arg1 = reinterpret_cast< wxWindow * >(argp1);
33648 {
33649 PyThreadState* __tstate = wxPyBeginAllowThreads();
33650 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33651 wxPyEndAllowThreads(__tstate);
33652 if (PyErr_Occurred()) SWIG_fail;
33653 }
33654 {
33655 resultobj = wxPyMake_wxObject(result, 0);
33656 }
33657 return resultobj;
33658 fail:
33659 return NULL;
33660 }
33661
33662
33663 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33664 PyObject *resultobj = 0;
33665 wxWindow *arg1 = (wxWindow *) 0 ;
33666 bool result;
33667 void *argp1 = 0 ;
33668 int res1 = 0 ;
33669 PyObject *swig_obj[1] ;
33670
33671 if (!args) SWIG_fail;
33672 swig_obj[0] = args;
33673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33674 if (!SWIG_IsOK(res1)) {
33675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33676 }
33677 arg1 = reinterpret_cast< wxWindow * >(argp1);
33678 {
33679 PyThreadState* __tstate = wxPyBeginAllowThreads();
33680 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33681 wxPyEndAllowThreads(__tstate);
33682 if (PyErr_Occurred()) SWIG_fail;
33683 }
33684 {
33685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33686 }
33687 return resultobj;
33688 fail:
33689 return NULL;
33690 }
33691
33692
33693 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33694 PyObject *resultobj = 0;
33695 wxWindow *arg1 = (wxWindow *) 0 ;
33696 wxWindow *arg2 = (wxWindow *) 0 ;
33697 bool result;
33698 void *argp1 = 0 ;
33699 int res1 = 0 ;
33700 void *argp2 = 0 ;
33701 int res2 = 0 ;
33702 PyObject * obj0 = 0 ;
33703 PyObject * obj1 = 0 ;
33704 char * kwnames[] = {
33705 (char *) "self",(char *) "newParent", NULL
33706 };
33707
33708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33710 if (!SWIG_IsOK(res1)) {
33711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33712 }
33713 arg1 = reinterpret_cast< wxWindow * >(argp1);
33714 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33715 if (!SWIG_IsOK(res2)) {
33716 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33717 }
33718 arg2 = reinterpret_cast< wxWindow * >(argp2);
33719 {
33720 PyThreadState* __tstate = wxPyBeginAllowThreads();
33721 result = (bool)(arg1)->Reparent(arg2);
33722 wxPyEndAllowThreads(__tstate);
33723 if (PyErr_Occurred()) SWIG_fail;
33724 }
33725 {
33726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33727 }
33728 return resultobj;
33729 fail:
33730 return NULL;
33731 }
33732
33733
33734 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33735 PyObject *resultobj = 0;
33736 wxWindow *arg1 = (wxWindow *) 0 ;
33737 wxWindow *arg2 = (wxWindow *) 0 ;
33738 void *argp1 = 0 ;
33739 int res1 = 0 ;
33740 void *argp2 = 0 ;
33741 int res2 = 0 ;
33742 PyObject * obj0 = 0 ;
33743 PyObject * obj1 = 0 ;
33744 char * kwnames[] = {
33745 (char *) "self",(char *) "child", NULL
33746 };
33747
33748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33750 if (!SWIG_IsOK(res1)) {
33751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33752 }
33753 arg1 = reinterpret_cast< wxWindow * >(argp1);
33754 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33755 if (!SWIG_IsOK(res2)) {
33756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33757 }
33758 arg2 = reinterpret_cast< wxWindow * >(argp2);
33759 {
33760 PyThreadState* __tstate = wxPyBeginAllowThreads();
33761 (arg1)->AddChild(arg2);
33762 wxPyEndAllowThreads(__tstate);
33763 if (PyErr_Occurred()) SWIG_fail;
33764 }
33765 resultobj = SWIG_Py_Void();
33766 return resultobj;
33767 fail:
33768 return NULL;
33769 }
33770
33771
33772 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33773 PyObject *resultobj = 0;
33774 wxWindow *arg1 = (wxWindow *) 0 ;
33775 wxWindow *arg2 = (wxWindow *) 0 ;
33776 void *argp1 = 0 ;
33777 int res1 = 0 ;
33778 void *argp2 = 0 ;
33779 int res2 = 0 ;
33780 PyObject * obj0 = 0 ;
33781 PyObject * obj1 = 0 ;
33782 char * kwnames[] = {
33783 (char *) "self",(char *) "child", NULL
33784 };
33785
33786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33788 if (!SWIG_IsOK(res1)) {
33789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33790 }
33791 arg1 = reinterpret_cast< wxWindow * >(argp1);
33792 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33793 if (!SWIG_IsOK(res2)) {
33794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33795 }
33796 arg2 = reinterpret_cast< wxWindow * >(argp2);
33797 {
33798 PyThreadState* __tstate = wxPyBeginAllowThreads();
33799 (arg1)->RemoveChild(arg2);
33800 wxPyEndAllowThreads(__tstate);
33801 if (PyErr_Occurred()) SWIG_fail;
33802 }
33803 resultobj = SWIG_Py_Void();
33804 return resultobj;
33805 fail:
33806 return NULL;
33807 }
33808
33809
33810 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33811 PyObject *resultobj = 0;
33812 wxWindow *arg1 = (wxWindow *) 0 ;
33813 bool arg2 ;
33814 void *argp1 = 0 ;
33815 int res1 = 0 ;
33816 bool val2 ;
33817 int ecode2 = 0 ;
33818 PyObject * obj0 = 0 ;
33819 PyObject * obj1 = 0 ;
33820 char * kwnames[] = {
33821 (char *) "self",(char *) "on", NULL
33822 };
33823
33824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33826 if (!SWIG_IsOK(res1)) {
33827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33828 }
33829 arg1 = reinterpret_cast< wxWindow * >(argp1);
33830 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33831 if (!SWIG_IsOK(ecode2)) {
33832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33833 }
33834 arg2 = static_cast< bool >(val2);
33835 {
33836 PyThreadState* __tstate = wxPyBeginAllowThreads();
33837 (arg1)->SetDoubleBuffered(arg2);
33838 wxPyEndAllowThreads(__tstate);
33839 if (PyErr_Occurred()) SWIG_fail;
33840 }
33841 resultobj = SWIG_Py_Void();
33842 return resultobj;
33843 fail:
33844 return NULL;
33845 }
33846
33847
33848 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33849 PyObject *resultobj = 0;
33850 wxWindow *arg1 = (wxWindow *) 0 ;
33851 long arg2 ;
33852 wxWindow *result = 0 ;
33853 void *argp1 = 0 ;
33854 int res1 = 0 ;
33855 long val2 ;
33856 int ecode2 = 0 ;
33857 PyObject * obj0 = 0 ;
33858 PyObject * obj1 = 0 ;
33859 char * kwnames[] = {
33860 (char *) "self",(char *) "winid", NULL
33861 };
33862
33863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33865 if (!SWIG_IsOK(res1)) {
33866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33867 }
33868 arg1 = reinterpret_cast< wxWindow * >(argp1);
33869 ecode2 = SWIG_AsVal_long(obj1, &val2);
33870 if (!SWIG_IsOK(ecode2)) {
33871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33872 }
33873 arg2 = static_cast< long >(val2);
33874 {
33875 PyThreadState* __tstate = wxPyBeginAllowThreads();
33876 result = (wxWindow *)(arg1)->FindWindow(arg2);
33877 wxPyEndAllowThreads(__tstate);
33878 if (PyErr_Occurred()) SWIG_fail;
33879 }
33880 {
33881 resultobj = wxPyMake_wxObject(result, 0);
33882 }
33883 return resultobj;
33884 fail:
33885 return NULL;
33886 }
33887
33888
33889 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33890 PyObject *resultobj = 0;
33891 wxWindow *arg1 = (wxWindow *) 0 ;
33892 wxString *arg2 = 0 ;
33893 wxWindow *result = 0 ;
33894 void *argp1 = 0 ;
33895 int res1 = 0 ;
33896 bool temp2 = false ;
33897 PyObject * obj0 = 0 ;
33898 PyObject * obj1 = 0 ;
33899 char * kwnames[] = {
33900 (char *) "self",(char *) "name", NULL
33901 };
33902
33903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33905 if (!SWIG_IsOK(res1)) {
33906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33907 }
33908 arg1 = reinterpret_cast< wxWindow * >(argp1);
33909 {
33910 arg2 = wxString_in_helper(obj1);
33911 if (arg2 == NULL) SWIG_fail;
33912 temp2 = true;
33913 }
33914 {
33915 PyThreadState* __tstate = wxPyBeginAllowThreads();
33916 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33917 wxPyEndAllowThreads(__tstate);
33918 if (PyErr_Occurred()) SWIG_fail;
33919 }
33920 {
33921 resultobj = wxPyMake_wxObject(result, 0);
33922 }
33923 {
33924 if (temp2)
33925 delete arg2;
33926 }
33927 return resultobj;
33928 fail:
33929 {
33930 if (temp2)
33931 delete arg2;
33932 }
33933 return NULL;
33934 }
33935
33936
33937 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33938 PyObject *resultobj = 0;
33939 wxWindow *arg1 = (wxWindow *) 0 ;
33940 wxEvtHandler *result = 0 ;
33941 void *argp1 = 0 ;
33942 int res1 = 0 ;
33943 PyObject *swig_obj[1] ;
33944
33945 if (!args) SWIG_fail;
33946 swig_obj[0] = args;
33947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33948 if (!SWIG_IsOK(res1)) {
33949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33950 }
33951 arg1 = reinterpret_cast< wxWindow * >(argp1);
33952 {
33953 PyThreadState* __tstate = wxPyBeginAllowThreads();
33954 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33955 wxPyEndAllowThreads(__tstate);
33956 if (PyErr_Occurred()) SWIG_fail;
33957 }
33958 {
33959 resultobj = wxPyMake_wxObject(result, 0);
33960 }
33961 return resultobj;
33962 fail:
33963 return NULL;
33964 }
33965
33966
33967 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33968 PyObject *resultobj = 0;
33969 wxWindow *arg1 = (wxWindow *) 0 ;
33970 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33971 void *argp1 = 0 ;
33972 int res1 = 0 ;
33973 void *argp2 = 0 ;
33974 int res2 = 0 ;
33975 PyObject * obj0 = 0 ;
33976 PyObject * obj1 = 0 ;
33977 char * kwnames[] = {
33978 (char *) "self",(char *) "handler", NULL
33979 };
33980
33981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33983 if (!SWIG_IsOK(res1)) {
33984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33985 }
33986 arg1 = reinterpret_cast< wxWindow * >(argp1);
33987 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33988 if (!SWIG_IsOK(res2)) {
33989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33990 }
33991 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33992 {
33993 PyThreadState* __tstate = wxPyBeginAllowThreads();
33994 (arg1)->SetEventHandler(arg2);
33995 wxPyEndAllowThreads(__tstate);
33996 if (PyErr_Occurred()) SWIG_fail;
33997 }
33998 resultobj = SWIG_Py_Void();
33999 return resultobj;
34000 fail:
34001 return NULL;
34002 }
34003
34004
34005 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34006 PyObject *resultobj = 0;
34007 wxWindow *arg1 = (wxWindow *) 0 ;
34008 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34009 void *argp1 = 0 ;
34010 int res1 = 0 ;
34011 void *argp2 = 0 ;
34012 int res2 = 0 ;
34013 PyObject * obj0 = 0 ;
34014 PyObject * obj1 = 0 ;
34015 char * kwnames[] = {
34016 (char *) "self",(char *) "handler", NULL
34017 };
34018
34019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34021 if (!SWIG_IsOK(res1)) {
34022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34023 }
34024 arg1 = reinterpret_cast< wxWindow * >(argp1);
34025 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34026 if (!SWIG_IsOK(res2)) {
34027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34028 }
34029 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34030 {
34031 PyThreadState* __tstate = wxPyBeginAllowThreads();
34032 (arg1)->PushEventHandler(arg2);
34033 wxPyEndAllowThreads(__tstate);
34034 if (PyErr_Occurred()) SWIG_fail;
34035 }
34036 resultobj = SWIG_Py_Void();
34037 return resultobj;
34038 fail:
34039 return NULL;
34040 }
34041
34042
34043 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34044 PyObject *resultobj = 0;
34045 wxWindow *arg1 = (wxWindow *) 0 ;
34046 bool arg2 = (bool) false ;
34047 wxEvtHandler *result = 0 ;
34048 void *argp1 = 0 ;
34049 int res1 = 0 ;
34050 bool val2 ;
34051 int ecode2 = 0 ;
34052 PyObject * obj0 = 0 ;
34053 PyObject * obj1 = 0 ;
34054 char * kwnames[] = {
34055 (char *) "self",(char *) "deleteHandler", NULL
34056 };
34057
34058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34060 if (!SWIG_IsOK(res1)) {
34061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34062 }
34063 arg1 = reinterpret_cast< wxWindow * >(argp1);
34064 if (obj1) {
34065 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34066 if (!SWIG_IsOK(ecode2)) {
34067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34068 }
34069 arg2 = static_cast< bool >(val2);
34070 }
34071 {
34072 PyThreadState* __tstate = wxPyBeginAllowThreads();
34073 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34074 wxPyEndAllowThreads(__tstate);
34075 if (PyErr_Occurred()) SWIG_fail;
34076 }
34077 {
34078 resultobj = wxPyMake_wxObject(result, 0);
34079 }
34080 return resultobj;
34081 fail:
34082 return NULL;
34083 }
34084
34085
34086 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34087 PyObject *resultobj = 0;
34088 wxWindow *arg1 = (wxWindow *) 0 ;
34089 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34090 bool result;
34091 void *argp1 = 0 ;
34092 int res1 = 0 ;
34093 void *argp2 = 0 ;
34094 int res2 = 0 ;
34095 PyObject * obj0 = 0 ;
34096 PyObject * obj1 = 0 ;
34097 char * kwnames[] = {
34098 (char *) "self",(char *) "handler", NULL
34099 };
34100
34101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34103 if (!SWIG_IsOK(res1)) {
34104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34105 }
34106 arg1 = reinterpret_cast< wxWindow * >(argp1);
34107 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34108 if (!SWIG_IsOK(res2)) {
34109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34110 }
34111 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34112 {
34113 PyThreadState* __tstate = wxPyBeginAllowThreads();
34114 result = (bool)(arg1)->RemoveEventHandler(arg2);
34115 wxPyEndAllowThreads(__tstate);
34116 if (PyErr_Occurred()) SWIG_fail;
34117 }
34118 {
34119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34120 }
34121 return resultobj;
34122 fail:
34123 return NULL;
34124 }
34125
34126
34127 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34128 PyObject *resultobj = 0;
34129 wxWindow *arg1 = (wxWindow *) 0 ;
34130 wxValidator *arg2 = 0 ;
34131 void *argp1 = 0 ;
34132 int res1 = 0 ;
34133 void *argp2 = 0 ;
34134 int res2 = 0 ;
34135 PyObject * obj0 = 0 ;
34136 PyObject * obj1 = 0 ;
34137 char * kwnames[] = {
34138 (char *) "self",(char *) "validator", NULL
34139 };
34140
34141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34143 if (!SWIG_IsOK(res1)) {
34144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34145 }
34146 arg1 = reinterpret_cast< wxWindow * >(argp1);
34147 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34148 if (!SWIG_IsOK(res2)) {
34149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34150 }
34151 if (!argp2) {
34152 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34153 }
34154 arg2 = reinterpret_cast< wxValidator * >(argp2);
34155 {
34156 PyThreadState* __tstate = wxPyBeginAllowThreads();
34157 (arg1)->SetValidator((wxValidator const &)*arg2);
34158 wxPyEndAllowThreads(__tstate);
34159 if (PyErr_Occurred()) SWIG_fail;
34160 }
34161 resultobj = SWIG_Py_Void();
34162 return resultobj;
34163 fail:
34164 return NULL;
34165 }
34166
34167
34168 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34169 PyObject *resultobj = 0;
34170 wxWindow *arg1 = (wxWindow *) 0 ;
34171 wxValidator *result = 0 ;
34172 void *argp1 = 0 ;
34173 int res1 = 0 ;
34174 PyObject *swig_obj[1] ;
34175
34176 if (!args) SWIG_fail;
34177 swig_obj[0] = args;
34178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34179 if (!SWIG_IsOK(res1)) {
34180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34181 }
34182 arg1 = reinterpret_cast< wxWindow * >(argp1);
34183 {
34184 PyThreadState* __tstate = wxPyBeginAllowThreads();
34185 result = (wxValidator *)(arg1)->GetValidator();
34186 wxPyEndAllowThreads(__tstate);
34187 if (PyErr_Occurred()) SWIG_fail;
34188 }
34189 {
34190 resultobj = wxPyMake_wxObject(result, (bool)0);
34191 }
34192 return resultobj;
34193 fail:
34194 return NULL;
34195 }
34196
34197
34198 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34199 PyObject *resultobj = 0;
34200 wxWindow *arg1 = (wxWindow *) 0 ;
34201 bool result;
34202 void *argp1 = 0 ;
34203 int res1 = 0 ;
34204 PyObject *swig_obj[1] ;
34205
34206 if (!args) SWIG_fail;
34207 swig_obj[0] = args;
34208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34209 if (!SWIG_IsOK(res1)) {
34210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34211 }
34212 arg1 = reinterpret_cast< wxWindow * >(argp1);
34213 {
34214 PyThreadState* __tstate = wxPyBeginAllowThreads();
34215 result = (bool)(arg1)->Validate();
34216 wxPyEndAllowThreads(__tstate);
34217 if (PyErr_Occurred()) SWIG_fail;
34218 }
34219 {
34220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34221 }
34222 return resultobj;
34223 fail:
34224 return NULL;
34225 }
34226
34227
34228 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34229 PyObject *resultobj = 0;
34230 wxWindow *arg1 = (wxWindow *) 0 ;
34231 bool result;
34232 void *argp1 = 0 ;
34233 int res1 = 0 ;
34234 PyObject *swig_obj[1] ;
34235
34236 if (!args) SWIG_fail;
34237 swig_obj[0] = args;
34238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34239 if (!SWIG_IsOK(res1)) {
34240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34241 }
34242 arg1 = reinterpret_cast< wxWindow * >(argp1);
34243 {
34244 PyThreadState* __tstate = wxPyBeginAllowThreads();
34245 result = (bool)(arg1)->TransferDataToWindow();
34246 wxPyEndAllowThreads(__tstate);
34247 if (PyErr_Occurred()) SWIG_fail;
34248 }
34249 {
34250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34251 }
34252 return resultobj;
34253 fail:
34254 return NULL;
34255 }
34256
34257
34258 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34259 PyObject *resultobj = 0;
34260 wxWindow *arg1 = (wxWindow *) 0 ;
34261 bool result;
34262 void *argp1 = 0 ;
34263 int res1 = 0 ;
34264 PyObject *swig_obj[1] ;
34265
34266 if (!args) SWIG_fail;
34267 swig_obj[0] = args;
34268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34269 if (!SWIG_IsOK(res1)) {
34270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34271 }
34272 arg1 = reinterpret_cast< wxWindow * >(argp1);
34273 {
34274 PyThreadState* __tstate = wxPyBeginAllowThreads();
34275 result = (bool)(arg1)->TransferDataFromWindow();
34276 wxPyEndAllowThreads(__tstate);
34277 if (PyErr_Occurred()) SWIG_fail;
34278 }
34279 {
34280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34281 }
34282 return resultobj;
34283 fail:
34284 return NULL;
34285 }
34286
34287
34288 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34289 PyObject *resultobj = 0;
34290 wxWindow *arg1 = (wxWindow *) 0 ;
34291 void *argp1 = 0 ;
34292 int res1 = 0 ;
34293 PyObject *swig_obj[1] ;
34294
34295 if (!args) SWIG_fail;
34296 swig_obj[0] = args;
34297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34298 if (!SWIG_IsOK(res1)) {
34299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34300 }
34301 arg1 = reinterpret_cast< wxWindow * >(argp1);
34302 {
34303 PyThreadState* __tstate = wxPyBeginAllowThreads();
34304 (arg1)->InitDialog();
34305 wxPyEndAllowThreads(__tstate);
34306 if (PyErr_Occurred()) SWIG_fail;
34307 }
34308 resultobj = SWIG_Py_Void();
34309 return resultobj;
34310 fail:
34311 return NULL;
34312 }
34313
34314
34315 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34316 PyObject *resultobj = 0;
34317 wxWindow *arg1 = (wxWindow *) 0 ;
34318 wxAcceleratorTable *arg2 = 0 ;
34319 void *argp1 = 0 ;
34320 int res1 = 0 ;
34321 void *argp2 = 0 ;
34322 int res2 = 0 ;
34323 PyObject * obj0 = 0 ;
34324 PyObject * obj1 = 0 ;
34325 char * kwnames[] = {
34326 (char *) "self",(char *) "accel", NULL
34327 };
34328
34329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34331 if (!SWIG_IsOK(res1)) {
34332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34333 }
34334 arg1 = reinterpret_cast< wxWindow * >(argp1);
34335 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34336 if (!SWIG_IsOK(res2)) {
34337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34338 }
34339 if (!argp2) {
34340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34341 }
34342 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34343 {
34344 PyThreadState* __tstate = wxPyBeginAllowThreads();
34345 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34346 wxPyEndAllowThreads(__tstate);
34347 if (PyErr_Occurred()) SWIG_fail;
34348 }
34349 resultobj = SWIG_Py_Void();
34350 return resultobj;
34351 fail:
34352 return NULL;
34353 }
34354
34355
34356 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34357 PyObject *resultobj = 0;
34358 wxWindow *arg1 = (wxWindow *) 0 ;
34359 wxAcceleratorTable *result = 0 ;
34360 void *argp1 = 0 ;
34361 int res1 = 0 ;
34362 PyObject *swig_obj[1] ;
34363
34364 if (!args) SWIG_fail;
34365 swig_obj[0] = args;
34366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34367 if (!SWIG_IsOK(res1)) {
34368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34369 }
34370 arg1 = reinterpret_cast< wxWindow * >(argp1);
34371 {
34372 PyThreadState* __tstate = wxPyBeginAllowThreads();
34373 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34374 wxPyEndAllowThreads(__tstate);
34375 if (PyErr_Occurred()) SWIG_fail;
34376 }
34377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34378 return resultobj;
34379 fail:
34380 return NULL;
34381 }
34382
34383
34384 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34385 PyObject *resultobj = 0;
34386 wxWindow *arg1 = (wxWindow *) 0 ;
34387 int arg2 ;
34388 int arg3 ;
34389 int arg4 ;
34390 bool result;
34391 void *argp1 = 0 ;
34392 int res1 = 0 ;
34393 int val2 ;
34394 int ecode2 = 0 ;
34395 int val3 ;
34396 int ecode3 = 0 ;
34397 int val4 ;
34398 int ecode4 = 0 ;
34399 PyObject * obj0 = 0 ;
34400 PyObject * obj1 = 0 ;
34401 PyObject * obj2 = 0 ;
34402 PyObject * obj3 = 0 ;
34403 char * kwnames[] = {
34404 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34405 };
34406
34407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34409 if (!SWIG_IsOK(res1)) {
34410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34411 }
34412 arg1 = reinterpret_cast< wxWindow * >(argp1);
34413 ecode2 = SWIG_AsVal_int(obj1, &val2);
34414 if (!SWIG_IsOK(ecode2)) {
34415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34416 }
34417 arg2 = static_cast< int >(val2);
34418 ecode3 = SWIG_AsVal_int(obj2, &val3);
34419 if (!SWIG_IsOK(ecode3)) {
34420 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34421 }
34422 arg3 = static_cast< int >(val3);
34423 ecode4 = SWIG_AsVal_int(obj3, &val4);
34424 if (!SWIG_IsOK(ecode4)) {
34425 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34426 }
34427 arg4 = static_cast< int >(val4);
34428 {
34429 PyThreadState* __tstate = wxPyBeginAllowThreads();
34430 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34431 wxPyEndAllowThreads(__tstate);
34432 if (PyErr_Occurred()) SWIG_fail;
34433 }
34434 {
34435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34436 }
34437 return resultobj;
34438 fail:
34439 return NULL;
34440 }
34441
34442
34443 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34444 PyObject *resultobj = 0;
34445 wxWindow *arg1 = (wxWindow *) 0 ;
34446 int arg2 ;
34447 bool result;
34448 void *argp1 = 0 ;
34449 int res1 = 0 ;
34450 int val2 ;
34451 int ecode2 = 0 ;
34452 PyObject * obj0 = 0 ;
34453 PyObject * obj1 = 0 ;
34454 char * kwnames[] = {
34455 (char *) "self",(char *) "hotkeyId", NULL
34456 };
34457
34458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34460 if (!SWIG_IsOK(res1)) {
34461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34462 }
34463 arg1 = reinterpret_cast< wxWindow * >(argp1);
34464 ecode2 = SWIG_AsVal_int(obj1, &val2);
34465 if (!SWIG_IsOK(ecode2)) {
34466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34467 }
34468 arg2 = static_cast< int >(val2);
34469 {
34470 PyThreadState* __tstate = wxPyBeginAllowThreads();
34471 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34472 wxPyEndAllowThreads(__tstate);
34473 if (PyErr_Occurred()) SWIG_fail;
34474 }
34475 {
34476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34477 }
34478 return resultobj;
34479 fail:
34480 return NULL;
34481 }
34482
34483
34484 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34485 PyObject *resultobj = 0;
34486 wxWindow *arg1 = (wxWindow *) 0 ;
34487 wxPoint *arg2 = 0 ;
34488 wxPoint result;
34489 void *argp1 = 0 ;
34490 int res1 = 0 ;
34491 wxPoint temp2 ;
34492 PyObject * obj0 = 0 ;
34493 PyObject * obj1 = 0 ;
34494 char * kwnames[] = {
34495 (char *) "self",(char *) "pt", NULL
34496 };
34497
34498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34500 if (!SWIG_IsOK(res1)) {
34501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34502 }
34503 arg1 = reinterpret_cast< wxWindow * >(argp1);
34504 {
34505 arg2 = &temp2;
34506 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34507 }
34508 {
34509 PyThreadState* __tstate = wxPyBeginAllowThreads();
34510 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34511 wxPyEndAllowThreads(__tstate);
34512 if (PyErr_Occurred()) SWIG_fail;
34513 }
34514 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34515 return resultobj;
34516 fail:
34517 return NULL;
34518 }
34519
34520
34521 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34522 PyObject *resultobj = 0;
34523 wxWindow *arg1 = (wxWindow *) 0 ;
34524 wxSize *arg2 = 0 ;
34525 wxSize result;
34526 void *argp1 = 0 ;
34527 int res1 = 0 ;
34528 wxSize temp2 ;
34529 PyObject * obj0 = 0 ;
34530 PyObject * obj1 = 0 ;
34531 char * kwnames[] = {
34532 (char *) "self",(char *) "sz", NULL
34533 };
34534
34535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34537 if (!SWIG_IsOK(res1)) {
34538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34539 }
34540 arg1 = reinterpret_cast< wxWindow * >(argp1);
34541 {
34542 arg2 = &temp2;
34543 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34544 }
34545 {
34546 PyThreadState* __tstate = wxPyBeginAllowThreads();
34547 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34548 wxPyEndAllowThreads(__tstate);
34549 if (PyErr_Occurred()) SWIG_fail;
34550 }
34551 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34552 return resultobj;
34553 fail:
34554 return NULL;
34555 }
34556
34557
34558 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34559 PyObject *resultobj = 0;
34560 wxWindow *arg1 = (wxWindow *) 0 ;
34561 wxPoint *arg2 = 0 ;
34562 wxPoint result;
34563 void *argp1 = 0 ;
34564 int res1 = 0 ;
34565 wxPoint temp2 ;
34566 PyObject * obj0 = 0 ;
34567 PyObject * obj1 = 0 ;
34568 char * kwnames[] = {
34569 (char *) "self",(char *) "pt", NULL
34570 };
34571
34572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34574 if (!SWIG_IsOK(res1)) {
34575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34576 }
34577 arg1 = reinterpret_cast< wxWindow * >(argp1);
34578 {
34579 arg2 = &temp2;
34580 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34581 }
34582 {
34583 PyThreadState* __tstate = wxPyBeginAllowThreads();
34584 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34585 wxPyEndAllowThreads(__tstate);
34586 if (PyErr_Occurred()) SWIG_fail;
34587 }
34588 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34589 return resultobj;
34590 fail:
34591 return NULL;
34592 }
34593
34594
34595 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34596 PyObject *resultobj = 0;
34597 wxWindow *arg1 = (wxWindow *) 0 ;
34598 wxSize *arg2 = 0 ;
34599 wxSize result;
34600 void *argp1 = 0 ;
34601 int res1 = 0 ;
34602 wxSize temp2 ;
34603 PyObject * obj0 = 0 ;
34604 PyObject * obj1 = 0 ;
34605 char * kwnames[] = {
34606 (char *) "self",(char *) "sz", NULL
34607 };
34608
34609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34611 if (!SWIG_IsOK(res1)) {
34612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34613 }
34614 arg1 = reinterpret_cast< wxWindow * >(argp1);
34615 {
34616 arg2 = &temp2;
34617 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34618 }
34619 {
34620 PyThreadState* __tstate = wxPyBeginAllowThreads();
34621 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34622 wxPyEndAllowThreads(__tstate);
34623 if (PyErr_Occurred()) SWIG_fail;
34624 }
34625 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34626 return resultobj;
34627 fail:
34628 return NULL;
34629 }
34630
34631
34632 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34633 PyObject *resultobj = 0;
34634 wxWindow *arg1 = (wxWindow *) 0 ;
34635 wxPoint *arg2 = 0 ;
34636 wxPoint result;
34637 void *argp1 = 0 ;
34638 int res1 = 0 ;
34639 wxPoint temp2 ;
34640 PyObject * obj0 = 0 ;
34641 PyObject * obj1 = 0 ;
34642 char * kwnames[] = {
34643 (char *) "self",(char *) "pt", NULL
34644 };
34645
34646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34648 if (!SWIG_IsOK(res1)) {
34649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34650 }
34651 arg1 = reinterpret_cast< wxWindow * >(argp1);
34652 {
34653 arg2 = &temp2;
34654 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34655 }
34656 {
34657 PyThreadState* __tstate = wxPyBeginAllowThreads();
34658 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34659 wxPyEndAllowThreads(__tstate);
34660 if (PyErr_Occurred()) SWIG_fail;
34661 }
34662 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34663 return resultobj;
34664 fail:
34665 return NULL;
34666 }
34667
34668
34669 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34670 PyObject *resultobj = 0;
34671 wxWindow *arg1 = (wxWindow *) 0 ;
34672 wxSize *arg2 = 0 ;
34673 wxSize result;
34674 void *argp1 = 0 ;
34675 int res1 = 0 ;
34676 wxSize temp2 ;
34677 PyObject * obj0 = 0 ;
34678 PyObject * obj1 = 0 ;
34679 char * kwnames[] = {
34680 (char *) "self",(char *) "sz", NULL
34681 };
34682
34683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34685 if (!SWIG_IsOK(res1)) {
34686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34687 }
34688 arg1 = reinterpret_cast< wxWindow * >(argp1);
34689 {
34690 arg2 = &temp2;
34691 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34692 }
34693 {
34694 PyThreadState* __tstate = wxPyBeginAllowThreads();
34695 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34696 wxPyEndAllowThreads(__tstate);
34697 if (PyErr_Occurred()) SWIG_fail;
34698 }
34699 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34700 return resultobj;
34701 fail:
34702 return NULL;
34703 }
34704
34705
34706 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34707 PyObject *resultobj = 0;
34708 wxWindow *arg1 = (wxWindow *) 0 ;
34709 int arg2 ;
34710 int arg3 ;
34711 void *argp1 = 0 ;
34712 int res1 = 0 ;
34713 int val2 ;
34714 int ecode2 = 0 ;
34715 int val3 ;
34716 int ecode3 = 0 ;
34717 PyObject * obj0 = 0 ;
34718 PyObject * obj1 = 0 ;
34719 PyObject * obj2 = 0 ;
34720 char * kwnames[] = {
34721 (char *) "self",(char *) "x",(char *) "y", NULL
34722 };
34723
34724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34726 if (!SWIG_IsOK(res1)) {
34727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34728 }
34729 arg1 = reinterpret_cast< wxWindow * >(argp1);
34730 ecode2 = SWIG_AsVal_int(obj1, &val2);
34731 if (!SWIG_IsOK(ecode2)) {
34732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34733 }
34734 arg2 = static_cast< int >(val2);
34735 ecode3 = SWIG_AsVal_int(obj2, &val3);
34736 if (!SWIG_IsOK(ecode3)) {
34737 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34738 }
34739 arg3 = static_cast< int >(val3);
34740 {
34741 PyThreadState* __tstate = wxPyBeginAllowThreads();
34742 (arg1)->WarpPointer(arg2,arg3);
34743 wxPyEndAllowThreads(__tstate);
34744 if (PyErr_Occurred()) SWIG_fail;
34745 }
34746 resultobj = SWIG_Py_Void();
34747 return resultobj;
34748 fail:
34749 return NULL;
34750 }
34751
34752
34753 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34754 PyObject *resultobj = 0;
34755 wxWindow *arg1 = (wxWindow *) 0 ;
34756 void *argp1 = 0 ;
34757 int res1 = 0 ;
34758 PyObject *swig_obj[1] ;
34759
34760 if (!args) SWIG_fail;
34761 swig_obj[0] = args;
34762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34763 if (!SWIG_IsOK(res1)) {
34764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34765 }
34766 arg1 = reinterpret_cast< wxWindow * >(argp1);
34767 {
34768 PyThreadState* __tstate = wxPyBeginAllowThreads();
34769 (arg1)->CaptureMouse();
34770 wxPyEndAllowThreads(__tstate);
34771 if (PyErr_Occurred()) SWIG_fail;
34772 }
34773 resultobj = SWIG_Py_Void();
34774 return resultobj;
34775 fail:
34776 return NULL;
34777 }
34778
34779
34780 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34781 PyObject *resultobj = 0;
34782 wxWindow *arg1 = (wxWindow *) 0 ;
34783 void *argp1 = 0 ;
34784 int res1 = 0 ;
34785 PyObject *swig_obj[1] ;
34786
34787 if (!args) SWIG_fail;
34788 swig_obj[0] = args;
34789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34790 if (!SWIG_IsOK(res1)) {
34791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34792 }
34793 arg1 = reinterpret_cast< wxWindow * >(argp1);
34794 {
34795 PyThreadState* __tstate = wxPyBeginAllowThreads();
34796 (arg1)->ReleaseMouse();
34797 wxPyEndAllowThreads(__tstate);
34798 if (PyErr_Occurred()) SWIG_fail;
34799 }
34800 resultobj = SWIG_Py_Void();
34801 return resultobj;
34802 fail:
34803 return NULL;
34804 }
34805
34806
34807 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34808 PyObject *resultobj = 0;
34809 wxWindow *result = 0 ;
34810
34811 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34812 {
34813 if (!wxPyCheckForApp()) SWIG_fail;
34814 PyThreadState* __tstate = wxPyBeginAllowThreads();
34815 result = (wxWindow *)wxWindow::GetCapture();
34816 wxPyEndAllowThreads(__tstate);
34817 if (PyErr_Occurred()) SWIG_fail;
34818 }
34819 {
34820 resultobj = wxPyMake_wxObject(result, 0);
34821 }
34822 return resultobj;
34823 fail:
34824 return NULL;
34825 }
34826
34827
34828 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34829 PyObject *resultobj = 0;
34830 wxWindow *arg1 = (wxWindow *) 0 ;
34831 bool result;
34832 void *argp1 = 0 ;
34833 int res1 = 0 ;
34834 PyObject *swig_obj[1] ;
34835
34836 if (!args) SWIG_fail;
34837 swig_obj[0] = args;
34838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34839 if (!SWIG_IsOK(res1)) {
34840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34841 }
34842 arg1 = reinterpret_cast< wxWindow * >(argp1);
34843 {
34844 PyThreadState* __tstate = wxPyBeginAllowThreads();
34845 result = (bool)((wxWindow const *)arg1)->HasCapture();
34846 wxPyEndAllowThreads(__tstate);
34847 if (PyErr_Occurred()) SWIG_fail;
34848 }
34849 {
34850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34851 }
34852 return resultobj;
34853 fail:
34854 return NULL;
34855 }
34856
34857
34858 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34859 PyObject *resultobj = 0;
34860 wxWindow *arg1 = (wxWindow *) 0 ;
34861 bool arg2 = (bool) true ;
34862 wxRect *arg3 = (wxRect *) NULL ;
34863 void *argp1 = 0 ;
34864 int res1 = 0 ;
34865 bool val2 ;
34866 int ecode2 = 0 ;
34867 void *argp3 = 0 ;
34868 int res3 = 0 ;
34869 PyObject * obj0 = 0 ;
34870 PyObject * obj1 = 0 ;
34871 PyObject * obj2 = 0 ;
34872 char * kwnames[] = {
34873 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34874 };
34875
34876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34878 if (!SWIG_IsOK(res1)) {
34879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34880 }
34881 arg1 = reinterpret_cast< wxWindow * >(argp1);
34882 if (obj1) {
34883 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34884 if (!SWIG_IsOK(ecode2)) {
34885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34886 }
34887 arg2 = static_cast< bool >(val2);
34888 }
34889 if (obj2) {
34890 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34891 if (!SWIG_IsOK(res3)) {
34892 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34893 }
34894 arg3 = reinterpret_cast< wxRect * >(argp3);
34895 }
34896 {
34897 PyThreadState* __tstate = wxPyBeginAllowThreads();
34898 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34899 wxPyEndAllowThreads(__tstate);
34900 if (PyErr_Occurred()) SWIG_fail;
34901 }
34902 resultobj = SWIG_Py_Void();
34903 return resultobj;
34904 fail:
34905 return NULL;
34906 }
34907
34908
34909 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34910 PyObject *resultobj = 0;
34911 wxWindow *arg1 = (wxWindow *) 0 ;
34912 wxRect *arg2 = 0 ;
34913 bool arg3 = (bool) true ;
34914 void *argp1 = 0 ;
34915 int res1 = 0 ;
34916 wxRect temp2 ;
34917 bool val3 ;
34918 int ecode3 = 0 ;
34919 PyObject * obj0 = 0 ;
34920 PyObject * obj1 = 0 ;
34921 PyObject * obj2 = 0 ;
34922 char * kwnames[] = {
34923 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34924 };
34925
34926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34928 if (!SWIG_IsOK(res1)) {
34929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34930 }
34931 arg1 = reinterpret_cast< wxWindow * >(argp1);
34932 {
34933 arg2 = &temp2;
34934 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34935 }
34936 if (obj2) {
34937 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34938 if (!SWIG_IsOK(ecode3)) {
34939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34940 }
34941 arg3 = static_cast< bool >(val3);
34942 }
34943 {
34944 PyThreadState* __tstate = wxPyBeginAllowThreads();
34945 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34946 wxPyEndAllowThreads(__tstate);
34947 if (PyErr_Occurred()) SWIG_fail;
34948 }
34949 resultobj = SWIG_Py_Void();
34950 return resultobj;
34951 fail:
34952 return NULL;
34953 }
34954
34955
34956 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34957 PyObject *resultobj = 0;
34958 wxWindow *arg1 = (wxWindow *) 0 ;
34959 void *argp1 = 0 ;
34960 int res1 = 0 ;
34961 PyObject *swig_obj[1] ;
34962
34963 if (!args) SWIG_fail;
34964 swig_obj[0] = args;
34965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34966 if (!SWIG_IsOK(res1)) {
34967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34968 }
34969 arg1 = reinterpret_cast< wxWindow * >(argp1);
34970 {
34971 PyThreadState* __tstate = wxPyBeginAllowThreads();
34972 (arg1)->Update();
34973 wxPyEndAllowThreads(__tstate);
34974 if (PyErr_Occurred()) SWIG_fail;
34975 }
34976 resultobj = SWIG_Py_Void();
34977 return resultobj;
34978 fail:
34979 return NULL;
34980 }
34981
34982
34983 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34984 PyObject *resultobj = 0;
34985 wxWindow *arg1 = (wxWindow *) 0 ;
34986 void *argp1 = 0 ;
34987 int res1 = 0 ;
34988 PyObject *swig_obj[1] ;
34989
34990 if (!args) SWIG_fail;
34991 swig_obj[0] = args;
34992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34993 if (!SWIG_IsOK(res1)) {
34994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34995 }
34996 arg1 = reinterpret_cast< wxWindow * >(argp1);
34997 {
34998 PyThreadState* __tstate = wxPyBeginAllowThreads();
34999 (arg1)->ClearBackground();
35000 wxPyEndAllowThreads(__tstate);
35001 if (PyErr_Occurred()) SWIG_fail;
35002 }
35003 resultobj = SWIG_Py_Void();
35004 return resultobj;
35005 fail:
35006 return NULL;
35007 }
35008
35009
35010 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35011 PyObject *resultobj = 0;
35012 wxWindow *arg1 = (wxWindow *) 0 ;
35013 void *argp1 = 0 ;
35014 int res1 = 0 ;
35015 PyObject *swig_obj[1] ;
35016
35017 if (!args) SWIG_fail;
35018 swig_obj[0] = args;
35019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35020 if (!SWIG_IsOK(res1)) {
35021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35022 }
35023 arg1 = reinterpret_cast< wxWindow * >(argp1);
35024 {
35025 PyThreadState* __tstate = wxPyBeginAllowThreads();
35026 (arg1)->Freeze();
35027 wxPyEndAllowThreads(__tstate);
35028 if (PyErr_Occurred()) SWIG_fail;
35029 }
35030 resultobj = SWIG_Py_Void();
35031 return resultobj;
35032 fail:
35033 return NULL;
35034 }
35035
35036
35037 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35038 PyObject *resultobj = 0;
35039 wxWindow *arg1 = (wxWindow *) 0 ;
35040 void *argp1 = 0 ;
35041 int res1 = 0 ;
35042 PyObject *swig_obj[1] ;
35043
35044 if (!args) SWIG_fail;
35045 swig_obj[0] = args;
35046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35047 if (!SWIG_IsOK(res1)) {
35048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35049 }
35050 arg1 = reinterpret_cast< wxWindow * >(argp1);
35051 {
35052 PyThreadState* __tstate = wxPyBeginAllowThreads();
35053 (arg1)->Thaw();
35054 wxPyEndAllowThreads(__tstate);
35055 if (PyErr_Occurred()) SWIG_fail;
35056 }
35057 resultobj = SWIG_Py_Void();
35058 return resultobj;
35059 fail:
35060 return NULL;
35061 }
35062
35063
35064 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35065 PyObject *resultobj = 0;
35066 wxWindow *arg1 = (wxWindow *) 0 ;
35067 wxDC *arg2 = 0 ;
35068 void *argp1 = 0 ;
35069 int res1 = 0 ;
35070 void *argp2 = 0 ;
35071 int res2 = 0 ;
35072 PyObject * obj0 = 0 ;
35073 PyObject * obj1 = 0 ;
35074 char * kwnames[] = {
35075 (char *) "self",(char *) "dc", NULL
35076 };
35077
35078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35080 if (!SWIG_IsOK(res1)) {
35081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35082 }
35083 arg1 = reinterpret_cast< wxWindow * >(argp1);
35084 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35085 if (!SWIG_IsOK(res2)) {
35086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35087 }
35088 if (!argp2) {
35089 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35090 }
35091 arg2 = reinterpret_cast< wxDC * >(argp2);
35092 {
35093 PyThreadState* __tstate = wxPyBeginAllowThreads();
35094 (arg1)->PrepareDC(*arg2);
35095 wxPyEndAllowThreads(__tstate);
35096 if (PyErr_Occurred()) SWIG_fail;
35097 }
35098 resultobj = SWIG_Py_Void();
35099 return resultobj;
35100 fail:
35101 return NULL;
35102 }
35103
35104
35105 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35106 PyObject *resultobj = 0;
35107 wxWindow *arg1 = (wxWindow *) 0 ;
35108 wxRegion *result = 0 ;
35109 void *argp1 = 0 ;
35110 int res1 = 0 ;
35111 PyObject *swig_obj[1] ;
35112
35113 if (!args) SWIG_fail;
35114 swig_obj[0] = args;
35115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35116 if (!SWIG_IsOK(res1)) {
35117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35118 }
35119 arg1 = reinterpret_cast< wxWindow * >(argp1);
35120 {
35121 PyThreadState* __tstate = wxPyBeginAllowThreads();
35122 {
35123 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35124 result = (wxRegion *) &_result_ref;
35125 }
35126 wxPyEndAllowThreads(__tstate);
35127 if (PyErr_Occurred()) SWIG_fail;
35128 }
35129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35130 return resultobj;
35131 fail:
35132 return NULL;
35133 }
35134
35135
35136 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35137 PyObject *resultobj = 0;
35138 wxWindow *arg1 = (wxWindow *) 0 ;
35139 wxRect result;
35140 void *argp1 = 0 ;
35141 int res1 = 0 ;
35142 PyObject *swig_obj[1] ;
35143
35144 if (!args) SWIG_fail;
35145 swig_obj[0] = args;
35146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35147 if (!SWIG_IsOK(res1)) {
35148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35149 }
35150 arg1 = reinterpret_cast< wxWindow * >(argp1);
35151 {
35152 PyThreadState* __tstate = wxPyBeginAllowThreads();
35153 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35154 wxPyEndAllowThreads(__tstate);
35155 if (PyErr_Occurred()) SWIG_fail;
35156 }
35157 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35158 return resultobj;
35159 fail:
35160 return NULL;
35161 }
35162
35163
35164 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35165 PyObject *resultobj = 0;
35166 wxWindow *arg1 = (wxWindow *) 0 ;
35167 int arg2 ;
35168 int arg3 ;
35169 int arg4 = (int) 1 ;
35170 int arg5 = (int) 1 ;
35171 bool result;
35172 void *argp1 = 0 ;
35173 int res1 = 0 ;
35174 int val2 ;
35175 int ecode2 = 0 ;
35176 int val3 ;
35177 int ecode3 = 0 ;
35178 int val4 ;
35179 int ecode4 = 0 ;
35180 int val5 ;
35181 int ecode5 = 0 ;
35182 PyObject * obj0 = 0 ;
35183 PyObject * obj1 = 0 ;
35184 PyObject * obj2 = 0 ;
35185 PyObject * obj3 = 0 ;
35186 PyObject * obj4 = 0 ;
35187 char * kwnames[] = {
35188 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35189 };
35190
35191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35193 if (!SWIG_IsOK(res1)) {
35194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35195 }
35196 arg1 = reinterpret_cast< wxWindow * >(argp1);
35197 ecode2 = SWIG_AsVal_int(obj1, &val2);
35198 if (!SWIG_IsOK(ecode2)) {
35199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35200 }
35201 arg2 = static_cast< int >(val2);
35202 ecode3 = SWIG_AsVal_int(obj2, &val3);
35203 if (!SWIG_IsOK(ecode3)) {
35204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35205 }
35206 arg3 = static_cast< int >(val3);
35207 if (obj3) {
35208 ecode4 = SWIG_AsVal_int(obj3, &val4);
35209 if (!SWIG_IsOK(ecode4)) {
35210 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35211 }
35212 arg4 = static_cast< int >(val4);
35213 }
35214 if (obj4) {
35215 ecode5 = SWIG_AsVal_int(obj4, &val5);
35216 if (!SWIG_IsOK(ecode5)) {
35217 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35218 }
35219 arg5 = static_cast< int >(val5);
35220 }
35221 {
35222 PyThreadState* __tstate = wxPyBeginAllowThreads();
35223 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35224 wxPyEndAllowThreads(__tstate);
35225 if (PyErr_Occurred()) SWIG_fail;
35226 }
35227 {
35228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35229 }
35230 return resultobj;
35231 fail:
35232 return NULL;
35233 }
35234
35235
35236 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35237 PyObject *resultobj = 0;
35238 wxWindow *arg1 = (wxWindow *) 0 ;
35239 wxPoint *arg2 = 0 ;
35240 bool result;
35241 void *argp1 = 0 ;
35242 int res1 = 0 ;
35243 wxPoint temp2 ;
35244 PyObject * obj0 = 0 ;
35245 PyObject * obj1 = 0 ;
35246 char * kwnames[] = {
35247 (char *) "self",(char *) "pt", NULL
35248 };
35249
35250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35252 if (!SWIG_IsOK(res1)) {
35253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35254 }
35255 arg1 = reinterpret_cast< wxWindow * >(argp1);
35256 {
35257 arg2 = &temp2;
35258 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35259 }
35260 {
35261 PyThreadState* __tstate = wxPyBeginAllowThreads();
35262 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35263 wxPyEndAllowThreads(__tstate);
35264 if (PyErr_Occurred()) SWIG_fail;
35265 }
35266 {
35267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35268 }
35269 return resultobj;
35270 fail:
35271 return NULL;
35272 }
35273
35274
35275 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35276 PyObject *resultobj = 0;
35277 wxWindow *arg1 = (wxWindow *) 0 ;
35278 wxRect *arg2 = 0 ;
35279 bool result;
35280 void *argp1 = 0 ;
35281 int res1 = 0 ;
35282 wxRect temp2 ;
35283 PyObject * obj0 = 0 ;
35284 PyObject * obj1 = 0 ;
35285 char * kwnames[] = {
35286 (char *) "self",(char *) "rect", NULL
35287 };
35288
35289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35291 if (!SWIG_IsOK(res1)) {
35292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35293 }
35294 arg1 = reinterpret_cast< wxWindow * >(argp1);
35295 {
35296 arg2 = &temp2;
35297 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35298 }
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35302 wxPyEndAllowThreads(__tstate);
35303 if (PyErr_Occurred()) SWIG_fail;
35304 }
35305 {
35306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35307 }
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35315 PyObject *resultobj = 0;
35316 wxWindow *arg1 = (wxWindow *) 0 ;
35317 SwigValueWrapper<wxVisualAttributes > result;
35318 void *argp1 = 0 ;
35319 int res1 = 0 ;
35320 PyObject *swig_obj[1] ;
35321
35322 if (!args) SWIG_fail;
35323 swig_obj[0] = args;
35324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35325 if (!SWIG_IsOK(res1)) {
35326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35327 }
35328 arg1 = reinterpret_cast< wxWindow * >(argp1);
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35336 return resultobj;
35337 fail:
35338 return NULL;
35339 }
35340
35341
35342 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35343 PyObject *resultobj = 0;
35344 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35345 SwigValueWrapper<wxVisualAttributes > result;
35346 int val1 ;
35347 int ecode1 = 0 ;
35348 PyObject * obj0 = 0 ;
35349 char * kwnames[] = {
35350 (char *) "variant", NULL
35351 };
35352
35353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35354 if (obj0) {
35355 ecode1 = SWIG_AsVal_int(obj0, &val1);
35356 if (!SWIG_IsOK(ecode1)) {
35357 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35358 }
35359 arg1 = static_cast< wxWindowVariant >(val1);
35360 }
35361 {
35362 if (!wxPyCheckForApp()) SWIG_fail;
35363 PyThreadState* __tstate = wxPyBeginAllowThreads();
35364 result = wxWindow::GetClassDefaultAttributes(arg1);
35365 wxPyEndAllowThreads(__tstate);
35366 if (PyErr_Occurred()) SWIG_fail;
35367 }
35368 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35369 return resultobj;
35370 fail:
35371 return NULL;
35372 }
35373
35374
35375 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35376 PyObject *resultobj = 0;
35377 wxWindow *arg1 = (wxWindow *) 0 ;
35378 wxColour *arg2 = 0 ;
35379 bool result;
35380 void *argp1 = 0 ;
35381 int res1 = 0 ;
35382 wxColour temp2 ;
35383 PyObject * obj0 = 0 ;
35384 PyObject * obj1 = 0 ;
35385 char * kwnames[] = {
35386 (char *) "self",(char *) "colour", NULL
35387 };
35388
35389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35391 if (!SWIG_IsOK(res1)) {
35392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35393 }
35394 arg1 = reinterpret_cast< wxWindow * >(argp1);
35395 {
35396 arg2 = &temp2;
35397 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35398 }
35399 {
35400 PyThreadState* __tstate = wxPyBeginAllowThreads();
35401 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35402 wxPyEndAllowThreads(__tstate);
35403 if (PyErr_Occurred()) SWIG_fail;
35404 }
35405 {
35406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35407 }
35408 return resultobj;
35409 fail:
35410 return NULL;
35411 }
35412
35413
35414 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35415 PyObject *resultobj = 0;
35416 wxWindow *arg1 = (wxWindow *) 0 ;
35417 wxColour *arg2 = 0 ;
35418 void *argp1 = 0 ;
35419 int res1 = 0 ;
35420 wxColour temp2 ;
35421 PyObject * obj0 = 0 ;
35422 PyObject * obj1 = 0 ;
35423 char * kwnames[] = {
35424 (char *) "self",(char *) "colour", NULL
35425 };
35426
35427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35429 if (!SWIG_IsOK(res1)) {
35430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35431 }
35432 arg1 = reinterpret_cast< wxWindow * >(argp1);
35433 {
35434 arg2 = &temp2;
35435 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35436 }
35437 {
35438 PyThreadState* __tstate = wxPyBeginAllowThreads();
35439 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35440 wxPyEndAllowThreads(__tstate);
35441 if (PyErr_Occurred()) SWIG_fail;
35442 }
35443 resultobj = SWIG_Py_Void();
35444 return resultobj;
35445 fail:
35446 return NULL;
35447 }
35448
35449
35450 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35451 PyObject *resultobj = 0;
35452 wxWindow *arg1 = (wxWindow *) 0 ;
35453 wxColour *arg2 = 0 ;
35454 bool result;
35455 void *argp1 = 0 ;
35456 int res1 = 0 ;
35457 wxColour temp2 ;
35458 PyObject * obj0 = 0 ;
35459 PyObject * obj1 = 0 ;
35460 char * kwnames[] = {
35461 (char *) "self",(char *) "colour", NULL
35462 };
35463
35464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35466 if (!SWIG_IsOK(res1)) {
35467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35468 }
35469 arg1 = reinterpret_cast< wxWindow * >(argp1);
35470 {
35471 arg2 = &temp2;
35472 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35473 }
35474 {
35475 PyThreadState* __tstate = wxPyBeginAllowThreads();
35476 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35477 wxPyEndAllowThreads(__tstate);
35478 if (PyErr_Occurred()) SWIG_fail;
35479 }
35480 {
35481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35482 }
35483 return resultobj;
35484 fail:
35485 return NULL;
35486 }
35487
35488
35489 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35490 PyObject *resultobj = 0;
35491 wxWindow *arg1 = (wxWindow *) 0 ;
35492 wxColour *arg2 = 0 ;
35493 void *argp1 = 0 ;
35494 int res1 = 0 ;
35495 wxColour temp2 ;
35496 PyObject * obj0 = 0 ;
35497 PyObject * obj1 = 0 ;
35498 char * kwnames[] = {
35499 (char *) "self",(char *) "colour", NULL
35500 };
35501
35502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35504 if (!SWIG_IsOK(res1)) {
35505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35506 }
35507 arg1 = reinterpret_cast< wxWindow * >(argp1);
35508 {
35509 arg2 = &temp2;
35510 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35511 }
35512 {
35513 PyThreadState* __tstate = wxPyBeginAllowThreads();
35514 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35515 wxPyEndAllowThreads(__tstate);
35516 if (PyErr_Occurred()) SWIG_fail;
35517 }
35518 resultobj = SWIG_Py_Void();
35519 return resultobj;
35520 fail:
35521 return NULL;
35522 }
35523
35524
35525 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35526 PyObject *resultobj = 0;
35527 wxWindow *arg1 = (wxWindow *) 0 ;
35528 wxColour result;
35529 void *argp1 = 0 ;
35530 int res1 = 0 ;
35531 PyObject *swig_obj[1] ;
35532
35533 if (!args) SWIG_fail;
35534 swig_obj[0] = args;
35535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35536 if (!SWIG_IsOK(res1)) {
35537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35538 }
35539 arg1 = reinterpret_cast< wxWindow * >(argp1);
35540 {
35541 PyThreadState* __tstate = wxPyBeginAllowThreads();
35542 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35543 wxPyEndAllowThreads(__tstate);
35544 if (PyErr_Occurred()) SWIG_fail;
35545 }
35546 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35547 return resultobj;
35548 fail:
35549 return NULL;
35550 }
35551
35552
35553 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35554 PyObject *resultobj = 0;
35555 wxWindow *arg1 = (wxWindow *) 0 ;
35556 wxColour result;
35557 void *argp1 = 0 ;
35558 int res1 = 0 ;
35559 PyObject *swig_obj[1] ;
35560
35561 if (!args) SWIG_fail;
35562 swig_obj[0] = args;
35563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35564 if (!SWIG_IsOK(res1)) {
35565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35566 }
35567 arg1 = reinterpret_cast< wxWindow * >(argp1);
35568 {
35569 PyThreadState* __tstate = wxPyBeginAllowThreads();
35570 result = ((wxWindow const *)arg1)->GetForegroundColour();
35571 wxPyEndAllowThreads(__tstate);
35572 if (PyErr_Occurred()) SWIG_fail;
35573 }
35574 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35575 return resultobj;
35576 fail:
35577 return NULL;
35578 }
35579
35580
35581 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35582 PyObject *resultobj = 0;
35583 wxWindow *arg1 = (wxWindow *) 0 ;
35584 bool result;
35585 void *argp1 = 0 ;
35586 int res1 = 0 ;
35587 PyObject *swig_obj[1] ;
35588
35589 if (!args) SWIG_fail;
35590 swig_obj[0] = args;
35591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35592 if (!SWIG_IsOK(res1)) {
35593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35594 }
35595 arg1 = reinterpret_cast< wxWindow * >(argp1);
35596 {
35597 PyThreadState* __tstate = wxPyBeginAllowThreads();
35598 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35599 wxPyEndAllowThreads(__tstate);
35600 if (PyErr_Occurred()) SWIG_fail;
35601 }
35602 {
35603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35604 }
35605 return resultobj;
35606 fail:
35607 return NULL;
35608 }
35609
35610
35611 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35612 PyObject *resultobj = 0;
35613 wxWindow *arg1 = (wxWindow *) 0 ;
35614 bool result;
35615 void *argp1 = 0 ;
35616 int res1 = 0 ;
35617 PyObject *swig_obj[1] ;
35618
35619 if (!args) SWIG_fail;
35620 swig_obj[0] = args;
35621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35622 if (!SWIG_IsOK(res1)) {
35623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35624 }
35625 arg1 = reinterpret_cast< wxWindow * >(argp1);
35626 {
35627 PyThreadState* __tstate = wxPyBeginAllowThreads();
35628 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35629 wxPyEndAllowThreads(__tstate);
35630 if (PyErr_Occurred()) SWIG_fail;
35631 }
35632 {
35633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35634 }
35635 return resultobj;
35636 fail:
35637 return NULL;
35638 }
35639
35640
35641 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35642 PyObject *resultobj = 0;
35643 wxWindow *arg1 = (wxWindow *) 0 ;
35644 wxBackgroundStyle arg2 ;
35645 bool result;
35646 void *argp1 = 0 ;
35647 int res1 = 0 ;
35648 int val2 ;
35649 int ecode2 = 0 ;
35650 PyObject * obj0 = 0 ;
35651 PyObject * obj1 = 0 ;
35652 char * kwnames[] = {
35653 (char *) "self",(char *) "style", NULL
35654 };
35655
35656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35658 if (!SWIG_IsOK(res1)) {
35659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35660 }
35661 arg1 = reinterpret_cast< wxWindow * >(argp1);
35662 ecode2 = SWIG_AsVal_int(obj1, &val2);
35663 if (!SWIG_IsOK(ecode2)) {
35664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35665 }
35666 arg2 = static_cast< wxBackgroundStyle >(val2);
35667 {
35668 PyThreadState* __tstate = wxPyBeginAllowThreads();
35669 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35670 wxPyEndAllowThreads(__tstate);
35671 if (PyErr_Occurred()) SWIG_fail;
35672 }
35673 {
35674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35675 }
35676 return resultobj;
35677 fail:
35678 return NULL;
35679 }
35680
35681
35682 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35683 PyObject *resultobj = 0;
35684 wxWindow *arg1 = (wxWindow *) 0 ;
35685 wxBackgroundStyle result;
35686 void *argp1 = 0 ;
35687 int res1 = 0 ;
35688 PyObject *swig_obj[1] ;
35689
35690 if (!args) SWIG_fail;
35691 swig_obj[0] = args;
35692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35693 if (!SWIG_IsOK(res1)) {
35694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35695 }
35696 arg1 = reinterpret_cast< wxWindow * >(argp1);
35697 {
35698 PyThreadState* __tstate = wxPyBeginAllowThreads();
35699 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35700 wxPyEndAllowThreads(__tstate);
35701 if (PyErr_Occurred()) SWIG_fail;
35702 }
35703 resultobj = SWIG_From_int(static_cast< int >(result));
35704 return resultobj;
35705 fail:
35706 return NULL;
35707 }
35708
35709
35710 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35711 PyObject *resultobj = 0;
35712 wxWindow *arg1 = (wxWindow *) 0 ;
35713 bool result;
35714 void *argp1 = 0 ;
35715 int res1 = 0 ;
35716 PyObject *swig_obj[1] ;
35717
35718 if (!args) SWIG_fail;
35719 swig_obj[0] = args;
35720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35721 if (!SWIG_IsOK(res1)) {
35722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35723 }
35724 arg1 = reinterpret_cast< wxWindow * >(argp1);
35725 {
35726 PyThreadState* __tstate = wxPyBeginAllowThreads();
35727 result = (bool)(arg1)->HasTransparentBackground();
35728 wxPyEndAllowThreads(__tstate);
35729 if (PyErr_Occurred()) SWIG_fail;
35730 }
35731 {
35732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35733 }
35734 return resultobj;
35735 fail:
35736 return NULL;
35737 }
35738
35739
35740 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35741 PyObject *resultobj = 0;
35742 wxWindow *arg1 = (wxWindow *) 0 ;
35743 wxCursor *arg2 = 0 ;
35744 bool result;
35745 void *argp1 = 0 ;
35746 int res1 = 0 ;
35747 void *argp2 = 0 ;
35748 int res2 = 0 ;
35749 PyObject * obj0 = 0 ;
35750 PyObject * obj1 = 0 ;
35751 char * kwnames[] = {
35752 (char *) "self",(char *) "cursor", NULL
35753 };
35754
35755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35757 if (!SWIG_IsOK(res1)) {
35758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35759 }
35760 arg1 = reinterpret_cast< wxWindow * >(argp1);
35761 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35762 if (!SWIG_IsOK(res2)) {
35763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35764 }
35765 if (!argp2) {
35766 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35767 }
35768 arg2 = reinterpret_cast< wxCursor * >(argp2);
35769 {
35770 PyThreadState* __tstate = wxPyBeginAllowThreads();
35771 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35772 wxPyEndAllowThreads(__tstate);
35773 if (PyErr_Occurred()) SWIG_fail;
35774 }
35775 {
35776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35777 }
35778 return resultobj;
35779 fail:
35780 return NULL;
35781 }
35782
35783
35784 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35785 PyObject *resultobj = 0;
35786 wxWindow *arg1 = (wxWindow *) 0 ;
35787 wxCursor result;
35788 void *argp1 = 0 ;
35789 int res1 = 0 ;
35790 PyObject *swig_obj[1] ;
35791
35792 if (!args) SWIG_fail;
35793 swig_obj[0] = args;
35794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35795 if (!SWIG_IsOK(res1)) {
35796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35797 }
35798 arg1 = reinterpret_cast< wxWindow * >(argp1);
35799 {
35800 PyThreadState* __tstate = wxPyBeginAllowThreads();
35801 result = (arg1)->GetCursor();
35802 wxPyEndAllowThreads(__tstate);
35803 if (PyErr_Occurred()) SWIG_fail;
35804 }
35805 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35806 return resultobj;
35807 fail:
35808 return NULL;
35809 }
35810
35811
35812 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35813 PyObject *resultobj = 0;
35814 wxWindow *arg1 = (wxWindow *) 0 ;
35815 wxFont *arg2 = 0 ;
35816 bool result;
35817 void *argp1 = 0 ;
35818 int res1 = 0 ;
35819 void *argp2 = 0 ;
35820 int res2 = 0 ;
35821 PyObject * obj0 = 0 ;
35822 PyObject * obj1 = 0 ;
35823 char * kwnames[] = {
35824 (char *) "self",(char *) "font", NULL
35825 };
35826
35827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35829 if (!SWIG_IsOK(res1)) {
35830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35831 }
35832 arg1 = reinterpret_cast< wxWindow * >(argp1);
35833 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35834 if (!SWIG_IsOK(res2)) {
35835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35836 }
35837 if (!argp2) {
35838 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35839 }
35840 arg2 = reinterpret_cast< wxFont * >(argp2);
35841 {
35842 PyThreadState* __tstate = wxPyBeginAllowThreads();
35843 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35844 wxPyEndAllowThreads(__tstate);
35845 if (PyErr_Occurred()) SWIG_fail;
35846 }
35847 {
35848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35849 }
35850 return resultobj;
35851 fail:
35852 return NULL;
35853 }
35854
35855
35856 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35857 PyObject *resultobj = 0;
35858 wxWindow *arg1 = (wxWindow *) 0 ;
35859 wxFont *arg2 = 0 ;
35860 void *argp1 = 0 ;
35861 int res1 = 0 ;
35862 void *argp2 = 0 ;
35863 int res2 = 0 ;
35864 PyObject * obj0 = 0 ;
35865 PyObject * obj1 = 0 ;
35866 char * kwnames[] = {
35867 (char *) "self",(char *) "font", NULL
35868 };
35869
35870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35872 if (!SWIG_IsOK(res1)) {
35873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35874 }
35875 arg1 = reinterpret_cast< wxWindow * >(argp1);
35876 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35877 if (!SWIG_IsOK(res2)) {
35878 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35879 }
35880 if (!argp2) {
35881 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35882 }
35883 arg2 = reinterpret_cast< wxFont * >(argp2);
35884 {
35885 PyThreadState* __tstate = wxPyBeginAllowThreads();
35886 (arg1)->SetOwnFont((wxFont const &)*arg2);
35887 wxPyEndAllowThreads(__tstate);
35888 if (PyErr_Occurred()) SWIG_fail;
35889 }
35890 resultobj = SWIG_Py_Void();
35891 return resultobj;
35892 fail:
35893 return NULL;
35894 }
35895
35896
35897 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35898 PyObject *resultobj = 0;
35899 wxWindow *arg1 = (wxWindow *) 0 ;
35900 wxFont result;
35901 void *argp1 = 0 ;
35902 int res1 = 0 ;
35903 PyObject *swig_obj[1] ;
35904
35905 if (!args) SWIG_fail;
35906 swig_obj[0] = args;
35907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35908 if (!SWIG_IsOK(res1)) {
35909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35910 }
35911 arg1 = reinterpret_cast< wxWindow * >(argp1);
35912 {
35913 PyThreadState* __tstate = wxPyBeginAllowThreads();
35914 result = (arg1)->GetFont();
35915 wxPyEndAllowThreads(__tstate);
35916 if (PyErr_Occurred()) SWIG_fail;
35917 }
35918 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35919 return resultobj;
35920 fail:
35921 return NULL;
35922 }
35923
35924
35925 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35926 PyObject *resultobj = 0;
35927 wxWindow *arg1 = (wxWindow *) 0 ;
35928 wxCaret *arg2 = (wxCaret *) 0 ;
35929 void *argp1 = 0 ;
35930 int res1 = 0 ;
35931 int res2 = 0 ;
35932 PyObject * obj0 = 0 ;
35933 PyObject * obj1 = 0 ;
35934 char * kwnames[] = {
35935 (char *) "self",(char *) "caret", NULL
35936 };
35937
35938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35940 if (!SWIG_IsOK(res1)) {
35941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35942 }
35943 arg1 = reinterpret_cast< wxWindow * >(argp1);
35944 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35945 if (!SWIG_IsOK(res2)) {
35946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35947 }
35948 {
35949 PyThreadState* __tstate = wxPyBeginAllowThreads();
35950 (arg1)->SetCaret(arg2);
35951 wxPyEndAllowThreads(__tstate);
35952 if (PyErr_Occurred()) SWIG_fail;
35953 }
35954 resultobj = SWIG_Py_Void();
35955 return resultobj;
35956 fail:
35957 return NULL;
35958 }
35959
35960
35961 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35962 PyObject *resultobj = 0;
35963 wxWindow *arg1 = (wxWindow *) 0 ;
35964 wxCaret *result = 0 ;
35965 void *argp1 = 0 ;
35966 int res1 = 0 ;
35967 PyObject *swig_obj[1] ;
35968
35969 if (!args) SWIG_fail;
35970 swig_obj[0] = args;
35971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35972 if (!SWIG_IsOK(res1)) {
35973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35974 }
35975 arg1 = reinterpret_cast< wxWindow * >(argp1);
35976 {
35977 PyThreadState* __tstate = wxPyBeginAllowThreads();
35978 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35979 wxPyEndAllowThreads(__tstate);
35980 if (PyErr_Occurred()) SWIG_fail;
35981 }
35982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35983 return resultobj;
35984 fail:
35985 return NULL;
35986 }
35987
35988
35989 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35990 PyObject *resultobj = 0;
35991 wxWindow *arg1 = (wxWindow *) 0 ;
35992 int result;
35993 void *argp1 = 0 ;
35994 int res1 = 0 ;
35995 PyObject *swig_obj[1] ;
35996
35997 if (!args) SWIG_fail;
35998 swig_obj[0] = args;
35999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36000 if (!SWIG_IsOK(res1)) {
36001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36002 }
36003 arg1 = reinterpret_cast< wxWindow * >(argp1);
36004 {
36005 PyThreadState* __tstate = wxPyBeginAllowThreads();
36006 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36007 wxPyEndAllowThreads(__tstate);
36008 if (PyErr_Occurred()) SWIG_fail;
36009 }
36010 resultobj = SWIG_From_int(static_cast< int >(result));
36011 return resultobj;
36012 fail:
36013 return NULL;
36014 }
36015
36016
36017 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36018 PyObject *resultobj = 0;
36019 wxWindow *arg1 = (wxWindow *) 0 ;
36020 int result;
36021 void *argp1 = 0 ;
36022 int res1 = 0 ;
36023 PyObject *swig_obj[1] ;
36024
36025 if (!args) SWIG_fail;
36026 swig_obj[0] = args;
36027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36028 if (!SWIG_IsOK(res1)) {
36029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36030 }
36031 arg1 = reinterpret_cast< wxWindow * >(argp1);
36032 {
36033 PyThreadState* __tstate = wxPyBeginAllowThreads();
36034 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36035 wxPyEndAllowThreads(__tstate);
36036 if (PyErr_Occurred()) SWIG_fail;
36037 }
36038 resultobj = SWIG_From_int(static_cast< int >(result));
36039 return resultobj;
36040 fail:
36041 return NULL;
36042 }
36043
36044
36045 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36046 PyObject *resultobj = 0;
36047 wxWindow *arg1 = (wxWindow *) 0 ;
36048 wxString *arg2 = 0 ;
36049 int *arg3 = (int *) 0 ;
36050 int *arg4 = (int *) 0 ;
36051 void *argp1 = 0 ;
36052 int res1 = 0 ;
36053 bool temp2 = false ;
36054 int temp3 ;
36055 int res3 = SWIG_TMPOBJ ;
36056 int temp4 ;
36057 int res4 = SWIG_TMPOBJ ;
36058 PyObject * obj0 = 0 ;
36059 PyObject * obj1 = 0 ;
36060 char * kwnames[] = {
36061 (char *) "self",(char *) "string", NULL
36062 };
36063
36064 arg3 = &temp3;
36065 arg4 = &temp4;
36066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36068 if (!SWIG_IsOK(res1)) {
36069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36070 }
36071 arg1 = reinterpret_cast< wxWindow * >(argp1);
36072 {
36073 arg2 = wxString_in_helper(obj1);
36074 if (arg2 == NULL) SWIG_fail;
36075 temp2 = true;
36076 }
36077 {
36078 PyThreadState* __tstate = wxPyBeginAllowThreads();
36079 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36080 wxPyEndAllowThreads(__tstate);
36081 if (PyErr_Occurred()) SWIG_fail;
36082 }
36083 resultobj = SWIG_Py_Void();
36084 if (SWIG_IsTmpObj(res3)) {
36085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36086 } else {
36087 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36089 }
36090 if (SWIG_IsTmpObj(res4)) {
36091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36092 } else {
36093 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36095 }
36096 {
36097 if (temp2)
36098 delete arg2;
36099 }
36100 return resultobj;
36101 fail:
36102 {
36103 if (temp2)
36104 delete arg2;
36105 }
36106 return NULL;
36107 }
36108
36109
36110 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36111 PyObject *resultobj = 0;
36112 wxWindow *arg1 = (wxWindow *) 0 ;
36113 wxString *arg2 = 0 ;
36114 int *arg3 = (int *) 0 ;
36115 int *arg4 = (int *) 0 ;
36116 int *arg5 = (int *) 0 ;
36117 int *arg6 = (int *) 0 ;
36118 wxFont *arg7 = (wxFont *) NULL ;
36119 void *argp1 = 0 ;
36120 int res1 = 0 ;
36121 bool temp2 = false ;
36122 int temp3 ;
36123 int res3 = SWIG_TMPOBJ ;
36124 int temp4 ;
36125 int res4 = SWIG_TMPOBJ ;
36126 int temp5 ;
36127 int res5 = SWIG_TMPOBJ ;
36128 int temp6 ;
36129 int res6 = SWIG_TMPOBJ ;
36130 void *argp7 = 0 ;
36131 int res7 = 0 ;
36132 PyObject * obj0 = 0 ;
36133 PyObject * obj1 = 0 ;
36134 PyObject * obj2 = 0 ;
36135 char * kwnames[] = {
36136 (char *) "self",(char *) "string",(char *) "font", NULL
36137 };
36138
36139 arg3 = &temp3;
36140 arg4 = &temp4;
36141 arg5 = &temp5;
36142 arg6 = &temp6;
36143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36145 if (!SWIG_IsOK(res1)) {
36146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36147 }
36148 arg1 = reinterpret_cast< wxWindow * >(argp1);
36149 {
36150 arg2 = wxString_in_helper(obj1);
36151 if (arg2 == NULL) SWIG_fail;
36152 temp2 = true;
36153 }
36154 if (obj2) {
36155 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36156 if (!SWIG_IsOK(res7)) {
36157 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36158 }
36159 arg7 = reinterpret_cast< wxFont * >(argp7);
36160 }
36161 {
36162 PyThreadState* __tstate = wxPyBeginAllowThreads();
36163 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36164 wxPyEndAllowThreads(__tstate);
36165 if (PyErr_Occurred()) SWIG_fail;
36166 }
36167 resultobj = SWIG_Py_Void();
36168 if (SWIG_IsTmpObj(res3)) {
36169 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36170 } else {
36171 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36172 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36173 }
36174 if (SWIG_IsTmpObj(res4)) {
36175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36176 } else {
36177 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36179 }
36180 if (SWIG_IsTmpObj(res5)) {
36181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36182 } else {
36183 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36184 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36185 }
36186 if (SWIG_IsTmpObj(res6)) {
36187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36188 } else {
36189 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36191 }
36192 {
36193 if (temp2)
36194 delete arg2;
36195 }
36196 return resultobj;
36197 fail:
36198 {
36199 if (temp2)
36200 delete arg2;
36201 }
36202 return NULL;
36203 }
36204
36205
36206 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36207 PyObject *resultobj = 0;
36208 wxWindow *arg1 = (wxWindow *) 0 ;
36209 int *arg2 = (int *) 0 ;
36210 int *arg3 = (int *) 0 ;
36211 void *argp1 = 0 ;
36212 int res1 = 0 ;
36213 int temp2 ;
36214 int res2 = 0 ;
36215 int temp3 ;
36216 int res3 = 0 ;
36217 PyObject * obj0 = 0 ;
36218 PyObject * obj1 = 0 ;
36219 PyObject * obj2 = 0 ;
36220 char * kwnames[] = {
36221 (char *) "self",(char *) "x",(char *) "y", NULL
36222 };
36223
36224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36226 if (!SWIG_IsOK(res1)) {
36227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36228 }
36229 arg1 = reinterpret_cast< wxWindow * >(argp1);
36230 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36231 int val;
36232 int ecode = SWIG_AsVal_int(obj1, &val);
36233 if (!SWIG_IsOK(ecode)) {
36234 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36235 }
36236 temp2 = static_cast< int >(val);
36237 arg2 = &temp2;
36238 res2 = SWIG_AddTmpMask(ecode);
36239 }
36240 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36241 int val;
36242 int ecode = SWIG_AsVal_int(obj2, &val);
36243 if (!SWIG_IsOK(ecode)) {
36244 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36245 }
36246 temp3 = static_cast< int >(val);
36247 arg3 = &temp3;
36248 res3 = SWIG_AddTmpMask(ecode);
36249 }
36250 {
36251 PyThreadState* __tstate = wxPyBeginAllowThreads();
36252 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36253 wxPyEndAllowThreads(__tstate);
36254 if (PyErr_Occurred()) SWIG_fail;
36255 }
36256 resultobj = SWIG_Py_Void();
36257 if (SWIG_IsTmpObj(res2)) {
36258 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36259 } else {
36260 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36261 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36262 }
36263 if (SWIG_IsTmpObj(res3)) {
36264 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36265 } else {
36266 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36267 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36268 }
36269 return resultobj;
36270 fail:
36271 return NULL;
36272 }
36273
36274
36275 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36276 PyObject *resultobj = 0;
36277 wxWindow *arg1 = (wxWindow *) 0 ;
36278 int *arg2 = (int *) 0 ;
36279 int *arg3 = (int *) 0 ;
36280 void *argp1 = 0 ;
36281 int res1 = 0 ;
36282 int temp2 ;
36283 int res2 = 0 ;
36284 int temp3 ;
36285 int res3 = 0 ;
36286 PyObject * obj0 = 0 ;
36287 PyObject * obj1 = 0 ;
36288 PyObject * obj2 = 0 ;
36289 char * kwnames[] = {
36290 (char *) "self",(char *) "x",(char *) "y", NULL
36291 };
36292
36293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36295 if (!SWIG_IsOK(res1)) {
36296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36297 }
36298 arg1 = reinterpret_cast< wxWindow * >(argp1);
36299 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36300 int val;
36301 int ecode = SWIG_AsVal_int(obj1, &val);
36302 if (!SWIG_IsOK(ecode)) {
36303 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36304 }
36305 temp2 = static_cast< int >(val);
36306 arg2 = &temp2;
36307 res2 = SWIG_AddTmpMask(ecode);
36308 }
36309 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36310 int val;
36311 int ecode = SWIG_AsVal_int(obj2, &val);
36312 if (!SWIG_IsOK(ecode)) {
36313 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36314 }
36315 temp3 = static_cast< int >(val);
36316 arg3 = &temp3;
36317 res3 = SWIG_AddTmpMask(ecode);
36318 }
36319 {
36320 PyThreadState* __tstate = wxPyBeginAllowThreads();
36321 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36322 wxPyEndAllowThreads(__tstate);
36323 if (PyErr_Occurred()) SWIG_fail;
36324 }
36325 resultobj = SWIG_Py_Void();
36326 if (SWIG_IsTmpObj(res2)) {
36327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36328 } else {
36329 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36331 }
36332 if (SWIG_IsTmpObj(res3)) {
36333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36334 } else {
36335 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36337 }
36338 return resultobj;
36339 fail:
36340 return NULL;
36341 }
36342
36343
36344 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36345 PyObject *resultobj = 0;
36346 wxWindow *arg1 = (wxWindow *) 0 ;
36347 wxPoint *arg2 = 0 ;
36348 wxPoint result;
36349 void *argp1 = 0 ;
36350 int res1 = 0 ;
36351 wxPoint temp2 ;
36352 PyObject * obj0 = 0 ;
36353 PyObject * obj1 = 0 ;
36354 char * kwnames[] = {
36355 (char *) "self",(char *) "pt", NULL
36356 };
36357
36358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36360 if (!SWIG_IsOK(res1)) {
36361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36362 }
36363 arg1 = reinterpret_cast< wxWindow * >(argp1);
36364 {
36365 arg2 = &temp2;
36366 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36367 }
36368 {
36369 PyThreadState* __tstate = wxPyBeginAllowThreads();
36370 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36371 wxPyEndAllowThreads(__tstate);
36372 if (PyErr_Occurred()) SWIG_fail;
36373 }
36374 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36375 return resultobj;
36376 fail:
36377 return NULL;
36378 }
36379
36380
36381 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36382 PyObject *resultobj = 0;
36383 wxWindow *arg1 = (wxWindow *) 0 ;
36384 wxPoint *arg2 = 0 ;
36385 wxPoint result;
36386 void *argp1 = 0 ;
36387 int res1 = 0 ;
36388 wxPoint temp2 ;
36389 PyObject * obj0 = 0 ;
36390 PyObject * obj1 = 0 ;
36391 char * kwnames[] = {
36392 (char *) "self",(char *) "pt", NULL
36393 };
36394
36395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36397 if (!SWIG_IsOK(res1)) {
36398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36399 }
36400 arg1 = reinterpret_cast< wxWindow * >(argp1);
36401 {
36402 arg2 = &temp2;
36403 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36404 }
36405 {
36406 PyThreadState* __tstate = wxPyBeginAllowThreads();
36407 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36408 wxPyEndAllowThreads(__tstate);
36409 if (PyErr_Occurred()) SWIG_fail;
36410 }
36411 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36412 return resultobj;
36413 fail:
36414 return NULL;
36415 }
36416
36417
36418 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36419 PyObject *resultobj = 0;
36420 wxWindow *arg1 = (wxWindow *) 0 ;
36421 int arg2 ;
36422 int arg3 ;
36423 wxHitTest result;
36424 void *argp1 = 0 ;
36425 int res1 = 0 ;
36426 int val2 ;
36427 int ecode2 = 0 ;
36428 int val3 ;
36429 int ecode3 = 0 ;
36430 PyObject * obj0 = 0 ;
36431 PyObject * obj1 = 0 ;
36432 PyObject * obj2 = 0 ;
36433 char * kwnames[] = {
36434 (char *) "self",(char *) "x",(char *) "y", NULL
36435 };
36436
36437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36439 if (!SWIG_IsOK(res1)) {
36440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36441 }
36442 arg1 = reinterpret_cast< wxWindow * >(argp1);
36443 ecode2 = SWIG_AsVal_int(obj1, &val2);
36444 if (!SWIG_IsOK(ecode2)) {
36445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36446 }
36447 arg2 = static_cast< int >(val2);
36448 ecode3 = SWIG_AsVal_int(obj2, &val3);
36449 if (!SWIG_IsOK(ecode3)) {
36450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36451 }
36452 arg3 = static_cast< int >(val3);
36453 {
36454 PyThreadState* __tstate = wxPyBeginAllowThreads();
36455 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36456 wxPyEndAllowThreads(__tstate);
36457 if (PyErr_Occurred()) SWIG_fail;
36458 }
36459 resultobj = SWIG_From_int(static_cast< int >(result));
36460 return resultobj;
36461 fail:
36462 return NULL;
36463 }
36464
36465
36466 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36467 PyObject *resultobj = 0;
36468 wxWindow *arg1 = (wxWindow *) 0 ;
36469 wxPoint *arg2 = 0 ;
36470 wxHitTest result;
36471 void *argp1 = 0 ;
36472 int res1 = 0 ;
36473 wxPoint temp2 ;
36474 PyObject * obj0 = 0 ;
36475 PyObject * obj1 = 0 ;
36476 char * kwnames[] = {
36477 (char *) "self",(char *) "pt", NULL
36478 };
36479
36480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36482 if (!SWIG_IsOK(res1)) {
36483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36484 }
36485 arg1 = reinterpret_cast< wxWindow * >(argp1);
36486 {
36487 arg2 = &temp2;
36488 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36489 }
36490 {
36491 PyThreadState* __tstate = wxPyBeginAllowThreads();
36492 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
36493 wxPyEndAllowThreads(__tstate);
36494 if (PyErr_Occurred()) SWIG_fail;
36495 }
36496 resultobj = SWIG_From_int(static_cast< int >(result));
36497 return resultobj;
36498 fail:
36499 return NULL;
36500 }
36501
36502
36503 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36504 PyObject *resultobj = 0;
36505 wxWindow *arg1 = (wxWindow *) 0 ;
36506 long arg2 ;
36507 wxBorder result;
36508 void *argp1 = 0 ;
36509 int res1 = 0 ;
36510 long val2 ;
36511 int ecode2 = 0 ;
36512
36513 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36515 if (!SWIG_IsOK(res1)) {
36516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36517 }
36518 arg1 = reinterpret_cast< wxWindow * >(argp1);
36519 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36520 if (!SWIG_IsOK(ecode2)) {
36521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36522 }
36523 arg2 = static_cast< long >(val2);
36524 {
36525 PyThreadState* __tstate = wxPyBeginAllowThreads();
36526 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36527 wxPyEndAllowThreads(__tstate);
36528 if (PyErr_Occurred()) SWIG_fail;
36529 }
36530 resultobj = SWIG_From_int(static_cast< int >(result));
36531 return resultobj;
36532 fail:
36533 return NULL;
36534 }
36535
36536
36537 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36538 PyObject *resultobj = 0;
36539 wxWindow *arg1 = (wxWindow *) 0 ;
36540 wxBorder result;
36541 void *argp1 = 0 ;
36542 int res1 = 0 ;
36543
36544 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36546 if (!SWIG_IsOK(res1)) {
36547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36548 }
36549 arg1 = reinterpret_cast< wxWindow * >(argp1);
36550 {
36551 PyThreadState* __tstate = wxPyBeginAllowThreads();
36552 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36553 wxPyEndAllowThreads(__tstate);
36554 if (PyErr_Occurred()) SWIG_fail;
36555 }
36556 resultobj = SWIG_From_int(static_cast< int >(result));
36557 return resultobj;
36558 fail:
36559 return NULL;
36560 }
36561
36562
36563 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36564 int argc;
36565 PyObject *argv[3];
36566
36567 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36568 --argc;
36569 if (argc == 1) {
36570 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36571 }
36572 if (argc == 2) {
36573 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36574 }
36575
36576 fail:
36577 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36578 return NULL;
36579 }
36580
36581
36582 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36583 PyObject *resultobj = 0;
36584 wxWindow *arg1 = (wxWindow *) 0 ;
36585 long arg2 = (long) wxUPDATE_UI_NONE ;
36586 void *argp1 = 0 ;
36587 int res1 = 0 ;
36588 long val2 ;
36589 int ecode2 = 0 ;
36590 PyObject * obj0 = 0 ;
36591 PyObject * obj1 = 0 ;
36592 char * kwnames[] = {
36593 (char *) "self",(char *) "flags", NULL
36594 };
36595
36596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36598 if (!SWIG_IsOK(res1)) {
36599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36600 }
36601 arg1 = reinterpret_cast< wxWindow * >(argp1);
36602 if (obj1) {
36603 ecode2 = SWIG_AsVal_long(obj1, &val2);
36604 if (!SWIG_IsOK(ecode2)) {
36605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36606 }
36607 arg2 = static_cast< long >(val2);
36608 }
36609 {
36610 PyThreadState* __tstate = wxPyBeginAllowThreads();
36611 (arg1)->UpdateWindowUI(arg2);
36612 wxPyEndAllowThreads(__tstate);
36613 if (PyErr_Occurred()) SWIG_fail;
36614 }
36615 resultobj = SWIG_Py_Void();
36616 return resultobj;
36617 fail:
36618 return NULL;
36619 }
36620
36621
36622 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36623 PyObject *resultobj = 0;
36624 wxWindow *arg1 = (wxWindow *) 0 ;
36625 wxMenu *arg2 = (wxMenu *) 0 ;
36626 int arg3 = (int) -1 ;
36627 int arg4 = (int) -1 ;
36628 bool result;
36629 void *argp1 = 0 ;
36630 int res1 = 0 ;
36631 void *argp2 = 0 ;
36632 int res2 = 0 ;
36633 int val3 ;
36634 int ecode3 = 0 ;
36635 int val4 ;
36636 int ecode4 = 0 ;
36637 PyObject * obj0 = 0 ;
36638 PyObject * obj1 = 0 ;
36639 PyObject * obj2 = 0 ;
36640 PyObject * obj3 = 0 ;
36641 char * kwnames[] = {
36642 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36643 };
36644
36645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36647 if (!SWIG_IsOK(res1)) {
36648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36649 }
36650 arg1 = reinterpret_cast< wxWindow * >(argp1);
36651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36652 if (!SWIG_IsOK(res2)) {
36653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36654 }
36655 arg2 = reinterpret_cast< wxMenu * >(argp2);
36656 if (obj2) {
36657 ecode3 = SWIG_AsVal_int(obj2, &val3);
36658 if (!SWIG_IsOK(ecode3)) {
36659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36660 }
36661 arg3 = static_cast< int >(val3);
36662 }
36663 if (obj3) {
36664 ecode4 = SWIG_AsVal_int(obj3, &val4);
36665 if (!SWIG_IsOK(ecode4)) {
36666 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36667 }
36668 arg4 = static_cast< int >(val4);
36669 }
36670 {
36671 PyThreadState* __tstate = wxPyBeginAllowThreads();
36672 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36673 wxPyEndAllowThreads(__tstate);
36674 if (PyErr_Occurred()) SWIG_fail;
36675 }
36676 {
36677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36678 }
36679 return resultobj;
36680 fail:
36681 return NULL;
36682 }
36683
36684
36685 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36686 PyObject *resultobj = 0;
36687 wxWindow *arg1 = (wxWindow *) 0 ;
36688 wxMenu *arg2 = (wxMenu *) 0 ;
36689 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36690 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36691 bool result;
36692 void *argp1 = 0 ;
36693 int res1 = 0 ;
36694 void *argp2 = 0 ;
36695 int res2 = 0 ;
36696 wxPoint temp3 ;
36697 PyObject * obj0 = 0 ;
36698 PyObject * obj1 = 0 ;
36699 PyObject * obj2 = 0 ;
36700 char * kwnames[] = {
36701 (char *) "self",(char *) "menu",(char *) "pos", NULL
36702 };
36703
36704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36706 if (!SWIG_IsOK(res1)) {
36707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36708 }
36709 arg1 = reinterpret_cast< wxWindow * >(argp1);
36710 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36711 if (!SWIG_IsOK(res2)) {
36712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36713 }
36714 arg2 = reinterpret_cast< wxMenu * >(argp2);
36715 if (obj2) {
36716 {
36717 arg3 = &temp3;
36718 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36719 }
36720 }
36721 {
36722 PyThreadState* __tstate = wxPyBeginAllowThreads();
36723 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36724 wxPyEndAllowThreads(__tstate);
36725 if (PyErr_Occurred()) SWIG_fail;
36726 }
36727 {
36728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36729 }
36730 return resultobj;
36731 fail:
36732 return NULL;
36733 }
36734
36735
36736 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36737 PyObject *resultobj = 0;
36738 wxWindow *arg1 = (wxWindow *) 0 ;
36739 bool result;
36740 void *argp1 = 0 ;
36741 int res1 = 0 ;
36742 PyObject *swig_obj[1] ;
36743
36744 if (!args) SWIG_fail;
36745 swig_obj[0] = args;
36746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36747 if (!SWIG_IsOK(res1)) {
36748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36749 }
36750 arg1 = reinterpret_cast< wxWindow * >(argp1);
36751 {
36752 PyThreadState* __tstate = wxPyBeginAllowThreads();
36753 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36754 wxPyEndAllowThreads(__tstate);
36755 if (PyErr_Occurred()) SWIG_fail;
36756 }
36757 {
36758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36759 }
36760 return resultobj;
36761 fail:
36762 return NULL;
36763 }
36764
36765
36766 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36767 PyObject *resultobj = 0;
36768 wxWindow *arg1 = (wxWindow *) 0 ;
36769 long result;
36770 void *argp1 = 0 ;
36771 int res1 = 0 ;
36772 PyObject *swig_obj[1] ;
36773
36774 if (!args) SWIG_fail;
36775 swig_obj[0] = args;
36776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36777 if (!SWIG_IsOK(res1)) {
36778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36779 }
36780 arg1 = reinterpret_cast< wxWindow * >(argp1);
36781 {
36782 PyThreadState* __tstate = wxPyBeginAllowThreads();
36783 result = (long)wxWindow_GetHandle(arg1);
36784 wxPyEndAllowThreads(__tstate);
36785 if (PyErr_Occurred()) SWIG_fail;
36786 }
36787 resultobj = SWIG_From_long(static_cast< long >(result));
36788 return resultobj;
36789 fail:
36790 return NULL;
36791 }
36792
36793
36794 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36795 PyObject *resultobj = 0;
36796 wxWindow *arg1 = (wxWindow *) 0 ;
36797 long arg2 ;
36798 void *argp1 = 0 ;
36799 int res1 = 0 ;
36800 long val2 ;
36801 int ecode2 = 0 ;
36802 PyObject * obj0 = 0 ;
36803 PyObject * obj1 = 0 ;
36804 char * kwnames[] = {
36805 (char *) "self",(char *) "handle", NULL
36806 };
36807
36808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36810 if (!SWIG_IsOK(res1)) {
36811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36812 }
36813 arg1 = reinterpret_cast< wxWindow * >(argp1);
36814 ecode2 = SWIG_AsVal_long(obj1, &val2);
36815 if (!SWIG_IsOK(ecode2)) {
36816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36817 }
36818 arg2 = static_cast< long >(val2);
36819 {
36820 PyThreadState* __tstate = wxPyBeginAllowThreads();
36821 wxWindow_AssociateHandle(arg1,arg2);
36822 wxPyEndAllowThreads(__tstate);
36823 if (PyErr_Occurred()) SWIG_fail;
36824 }
36825 resultobj = SWIG_Py_Void();
36826 return resultobj;
36827 fail:
36828 return NULL;
36829 }
36830
36831
36832 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36833 PyObject *resultobj = 0;
36834 wxWindow *arg1 = (wxWindow *) 0 ;
36835 void *argp1 = 0 ;
36836 int res1 = 0 ;
36837 PyObject *swig_obj[1] ;
36838
36839 if (!args) SWIG_fail;
36840 swig_obj[0] = args;
36841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36842 if (!SWIG_IsOK(res1)) {
36843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36844 }
36845 arg1 = reinterpret_cast< wxWindow * >(argp1);
36846 {
36847 PyThreadState* __tstate = wxPyBeginAllowThreads();
36848 (arg1)->DissociateHandle();
36849 wxPyEndAllowThreads(__tstate);
36850 if (PyErr_Occurred()) SWIG_fail;
36851 }
36852 resultobj = SWIG_Py_Void();
36853 return resultobj;
36854 fail:
36855 return NULL;
36856 }
36857
36858
36859 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36860 PyObject *resultobj = 0;
36861 wxWindow *arg1 = (wxWindow *) 0 ;
36862 int arg2 ;
36863 bool result;
36864 void *argp1 = 0 ;
36865 int res1 = 0 ;
36866 int val2 ;
36867 int ecode2 = 0 ;
36868 PyObject * obj0 = 0 ;
36869 PyObject * obj1 = 0 ;
36870 char * kwnames[] = {
36871 (char *) "self",(char *) "orient", NULL
36872 };
36873
36874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36876 if (!SWIG_IsOK(res1)) {
36877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36878 }
36879 arg1 = reinterpret_cast< wxWindow * >(argp1);
36880 ecode2 = SWIG_AsVal_int(obj1, &val2);
36881 if (!SWIG_IsOK(ecode2)) {
36882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36883 }
36884 arg2 = static_cast< int >(val2);
36885 {
36886 PyThreadState* __tstate = wxPyBeginAllowThreads();
36887 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36888 wxPyEndAllowThreads(__tstate);
36889 if (PyErr_Occurred()) SWIG_fail;
36890 }
36891 {
36892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36893 }
36894 return resultobj;
36895 fail:
36896 return NULL;
36897 }
36898
36899
36900 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36901 PyObject *resultobj = 0;
36902 wxWindow *arg1 = (wxWindow *) 0 ;
36903 int arg2 ;
36904 int arg3 ;
36905 int arg4 ;
36906 int arg5 ;
36907 bool arg6 = (bool) true ;
36908 void *argp1 = 0 ;
36909 int res1 = 0 ;
36910 int val2 ;
36911 int ecode2 = 0 ;
36912 int val3 ;
36913 int ecode3 = 0 ;
36914 int val4 ;
36915 int ecode4 = 0 ;
36916 int val5 ;
36917 int ecode5 = 0 ;
36918 bool val6 ;
36919 int ecode6 = 0 ;
36920 PyObject * obj0 = 0 ;
36921 PyObject * obj1 = 0 ;
36922 PyObject * obj2 = 0 ;
36923 PyObject * obj3 = 0 ;
36924 PyObject * obj4 = 0 ;
36925 PyObject * obj5 = 0 ;
36926 char * kwnames[] = {
36927 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36928 };
36929
36930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36932 if (!SWIG_IsOK(res1)) {
36933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36934 }
36935 arg1 = reinterpret_cast< wxWindow * >(argp1);
36936 ecode2 = SWIG_AsVal_int(obj1, &val2);
36937 if (!SWIG_IsOK(ecode2)) {
36938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36939 }
36940 arg2 = static_cast< int >(val2);
36941 ecode3 = SWIG_AsVal_int(obj2, &val3);
36942 if (!SWIG_IsOK(ecode3)) {
36943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36944 }
36945 arg3 = static_cast< int >(val3);
36946 ecode4 = SWIG_AsVal_int(obj3, &val4);
36947 if (!SWIG_IsOK(ecode4)) {
36948 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36949 }
36950 arg4 = static_cast< int >(val4);
36951 ecode5 = SWIG_AsVal_int(obj4, &val5);
36952 if (!SWIG_IsOK(ecode5)) {
36953 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36954 }
36955 arg5 = static_cast< int >(val5);
36956 if (obj5) {
36957 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36958 if (!SWIG_IsOK(ecode6)) {
36959 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36960 }
36961 arg6 = static_cast< bool >(val6);
36962 }
36963 {
36964 PyThreadState* __tstate = wxPyBeginAllowThreads();
36965 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36966 wxPyEndAllowThreads(__tstate);
36967 if (PyErr_Occurred()) SWIG_fail;
36968 }
36969 resultobj = SWIG_Py_Void();
36970 return resultobj;
36971 fail:
36972 return NULL;
36973 }
36974
36975
36976 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36977 PyObject *resultobj = 0;
36978 wxWindow *arg1 = (wxWindow *) 0 ;
36979 int arg2 ;
36980 int arg3 ;
36981 bool arg4 = (bool) true ;
36982 void *argp1 = 0 ;
36983 int res1 = 0 ;
36984 int val2 ;
36985 int ecode2 = 0 ;
36986 int val3 ;
36987 int ecode3 = 0 ;
36988 bool val4 ;
36989 int ecode4 = 0 ;
36990 PyObject * obj0 = 0 ;
36991 PyObject * obj1 = 0 ;
36992 PyObject * obj2 = 0 ;
36993 PyObject * obj3 = 0 ;
36994 char * kwnames[] = {
36995 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36996 };
36997
36998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37000 if (!SWIG_IsOK(res1)) {
37001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37002 }
37003 arg1 = reinterpret_cast< wxWindow * >(argp1);
37004 ecode2 = SWIG_AsVal_int(obj1, &val2);
37005 if (!SWIG_IsOK(ecode2)) {
37006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37007 }
37008 arg2 = static_cast< int >(val2);
37009 ecode3 = SWIG_AsVal_int(obj2, &val3);
37010 if (!SWIG_IsOK(ecode3)) {
37011 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37012 }
37013 arg3 = static_cast< int >(val3);
37014 if (obj3) {
37015 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37016 if (!SWIG_IsOK(ecode4)) {
37017 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37018 }
37019 arg4 = static_cast< bool >(val4);
37020 }
37021 {
37022 PyThreadState* __tstate = wxPyBeginAllowThreads();
37023 (arg1)->SetScrollPos(arg2,arg3,arg4);
37024 wxPyEndAllowThreads(__tstate);
37025 if (PyErr_Occurred()) SWIG_fail;
37026 }
37027 resultobj = SWIG_Py_Void();
37028 return resultobj;
37029 fail:
37030 return NULL;
37031 }
37032
37033
37034 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37035 PyObject *resultobj = 0;
37036 wxWindow *arg1 = (wxWindow *) 0 ;
37037 int arg2 ;
37038 int result;
37039 void *argp1 = 0 ;
37040 int res1 = 0 ;
37041 int val2 ;
37042 int ecode2 = 0 ;
37043 PyObject * obj0 = 0 ;
37044 PyObject * obj1 = 0 ;
37045 char * kwnames[] = {
37046 (char *) "self",(char *) "orientation", NULL
37047 };
37048
37049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37051 if (!SWIG_IsOK(res1)) {
37052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37053 }
37054 arg1 = reinterpret_cast< wxWindow * >(argp1);
37055 ecode2 = SWIG_AsVal_int(obj1, &val2);
37056 if (!SWIG_IsOK(ecode2)) {
37057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37058 }
37059 arg2 = static_cast< int >(val2);
37060 {
37061 PyThreadState* __tstate = wxPyBeginAllowThreads();
37062 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37063 wxPyEndAllowThreads(__tstate);
37064 if (PyErr_Occurred()) SWIG_fail;
37065 }
37066 resultobj = SWIG_From_int(static_cast< int >(result));
37067 return resultobj;
37068 fail:
37069 return NULL;
37070 }
37071
37072
37073 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37074 PyObject *resultobj = 0;
37075 wxWindow *arg1 = (wxWindow *) 0 ;
37076 int arg2 ;
37077 int result;
37078 void *argp1 = 0 ;
37079 int res1 = 0 ;
37080 int val2 ;
37081 int ecode2 = 0 ;
37082 PyObject * obj0 = 0 ;
37083 PyObject * obj1 = 0 ;
37084 char * kwnames[] = {
37085 (char *) "self",(char *) "orientation", NULL
37086 };
37087
37088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37090 if (!SWIG_IsOK(res1)) {
37091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37092 }
37093 arg1 = reinterpret_cast< wxWindow * >(argp1);
37094 ecode2 = SWIG_AsVal_int(obj1, &val2);
37095 if (!SWIG_IsOK(ecode2)) {
37096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37097 }
37098 arg2 = static_cast< int >(val2);
37099 {
37100 PyThreadState* __tstate = wxPyBeginAllowThreads();
37101 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37102 wxPyEndAllowThreads(__tstate);
37103 if (PyErr_Occurred()) SWIG_fail;
37104 }
37105 resultobj = SWIG_From_int(static_cast< int >(result));
37106 return resultobj;
37107 fail:
37108 return NULL;
37109 }
37110
37111
37112 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37113 PyObject *resultobj = 0;
37114 wxWindow *arg1 = (wxWindow *) 0 ;
37115 int arg2 ;
37116 int result;
37117 void *argp1 = 0 ;
37118 int res1 = 0 ;
37119 int val2 ;
37120 int ecode2 = 0 ;
37121 PyObject * obj0 = 0 ;
37122 PyObject * obj1 = 0 ;
37123 char * kwnames[] = {
37124 (char *) "self",(char *) "orientation", NULL
37125 };
37126
37127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37129 if (!SWIG_IsOK(res1)) {
37130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37131 }
37132 arg1 = reinterpret_cast< wxWindow * >(argp1);
37133 ecode2 = SWIG_AsVal_int(obj1, &val2);
37134 if (!SWIG_IsOK(ecode2)) {
37135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37136 }
37137 arg2 = static_cast< int >(val2);
37138 {
37139 PyThreadState* __tstate = wxPyBeginAllowThreads();
37140 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37141 wxPyEndAllowThreads(__tstate);
37142 if (PyErr_Occurred()) SWIG_fail;
37143 }
37144 resultobj = SWIG_From_int(static_cast< int >(result));
37145 return resultobj;
37146 fail:
37147 return NULL;
37148 }
37149
37150
37151 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37152 PyObject *resultobj = 0;
37153 wxWindow *arg1 = (wxWindow *) 0 ;
37154 int arg2 ;
37155 int arg3 ;
37156 wxRect *arg4 = (wxRect *) NULL ;
37157 void *argp1 = 0 ;
37158 int res1 = 0 ;
37159 int val2 ;
37160 int ecode2 = 0 ;
37161 int val3 ;
37162 int ecode3 = 0 ;
37163 void *argp4 = 0 ;
37164 int res4 = 0 ;
37165 PyObject * obj0 = 0 ;
37166 PyObject * obj1 = 0 ;
37167 PyObject * obj2 = 0 ;
37168 PyObject * obj3 = 0 ;
37169 char * kwnames[] = {
37170 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37171 };
37172
37173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37175 if (!SWIG_IsOK(res1)) {
37176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37177 }
37178 arg1 = reinterpret_cast< wxWindow * >(argp1);
37179 ecode2 = SWIG_AsVal_int(obj1, &val2);
37180 if (!SWIG_IsOK(ecode2)) {
37181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37182 }
37183 arg2 = static_cast< int >(val2);
37184 ecode3 = SWIG_AsVal_int(obj2, &val3);
37185 if (!SWIG_IsOK(ecode3)) {
37186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37187 }
37188 arg3 = static_cast< int >(val3);
37189 if (obj3) {
37190 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37191 if (!SWIG_IsOK(res4)) {
37192 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37193 }
37194 arg4 = reinterpret_cast< wxRect * >(argp4);
37195 }
37196 {
37197 PyThreadState* __tstate = wxPyBeginAllowThreads();
37198 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37199 wxPyEndAllowThreads(__tstate);
37200 if (PyErr_Occurred()) SWIG_fail;
37201 }
37202 resultobj = SWIG_Py_Void();
37203 return resultobj;
37204 fail:
37205 return NULL;
37206 }
37207
37208
37209 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37210 PyObject *resultobj = 0;
37211 wxWindow *arg1 = (wxWindow *) 0 ;
37212 int arg2 ;
37213 bool result;
37214 void *argp1 = 0 ;
37215 int res1 = 0 ;
37216 int val2 ;
37217 int ecode2 = 0 ;
37218 PyObject * obj0 = 0 ;
37219 PyObject * obj1 = 0 ;
37220 char * kwnames[] = {
37221 (char *) "self",(char *) "lines", NULL
37222 };
37223
37224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37226 if (!SWIG_IsOK(res1)) {
37227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37228 }
37229 arg1 = reinterpret_cast< wxWindow * >(argp1);
37230 ecode2 = SWIG_AsVal_int(obj1, &val2);
37231 if (!SWIG_IsOK(ecode2)) {
37232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37233 }
37234 arg2 = static_cast< int >(val2);
37235 {
37236 PyThreadState* __tstate = wxPyBeginAllowThreads();
37237 result = (bool)(arg1)->ScrollLines(arg2);
37238 wxPyEndAllowThreads(__tstate);
37239 if (PyErr_Occurred()) SWIG_fail;
37240 }
37241 {
37242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37243 }
37244 return resultobj;
37245 fail:
37246 return NULL;
37247 }
37248
37249
37250 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37251 PyObject *resultobj = 0;
37252 wxWindow *arg1 = (wxWindow *) 0 ;
37253 int arg2 ;
37254 bool result;
37255 void *argp1 = 0 ;
37256 int res1 = 0 ;
37257 int val2 ;
37258 int ecode2 = 0 ;
37259 PyObject * obj0 = 0 ;
37260 PyObject * obj1 = 0 ;
37261 char * kwnames[] = {
37262 (char *) "self",(char *) "pages", NULL
37263 };
37264
37265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37267 if (!SWIG_IsOK(res1)) {
37268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37269 }
37270 arg1 = reinterpret_cast< wxWindow * >(argp1);
37271 ecode2 = SWIG_AsVal_int(obj1, &val2);
37272 if (!SWIG_IsOK(ecode2)) {
37273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37274 }
37275 arg2 = static_cast< int >(val2);
37276 {
37277 PyThreadState* __tstate = wxPyBeginAllowThreads();
37278 result = (bool)(arg1)->ScrollPages(arg2);
37279 wxPyEndAllowThreads(__tstate);
37280 if (PyErr_Occurred()) SWIG_fail;
37281 }
37282 {
37283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37284 }
37285 return resultobj;
37286 fail:
37287 return NULL;
37288 }
37289
37290
37291 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37292 PyObject *resultobj = 0;
37293 wxWindow *arg1 = (wxWindow *) 0 ;
37294 bool result;
37295 void *argp1 = 0 ;
37296 int res1 = 0 ;
37297 PyObject *swig_obj[1] ;
37298
37299 if (!args) SWIG_fail;
37300 swig_obj[0] = args;
37301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37302 if (!SWIG_IsOK(res1)) {
37303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37304 }
37305 arg1 = reinterpret_cast< wxWindow * >(argp1);
37306 {
37307 PyThreadState* __tstate = wxPyBeginAllowThreads();
37308 result = (bool)(arg1)->LineUp();
37309 wxPyEndAllowThreads(__tstate);
37310 if (PyErr_Occurred()) SWIG_fail;
37311 }
37312 {
37313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37314 }
37315 return resultobj;
37316 fail:
37317 return NULL;
37318 }
37319
37320
37321 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37322 PyObject *resultobj = 0;
37323 wxWindow *arg1 = (wxWindow *) 0 ;
37324 bool result;
37325 void *argp1 = 0 ;
37326 int res1 = 0 ;
37327 PyObject *swig_obj[1] ;
37328
37329 if (!args) SWIG_fail;
37330 swig_obj[0] = args;
37331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37332 if (!SWIG_IsOK(res1)) {
37333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37334 }
37335 arg1 = reinterpret_cast< wxWindow * >(argp1);
37336 {
37337 PyThreadState* __tstate = wxPyBeginAllowThreads();
37338 result = (bool)(arg1)->LineDown();
37339 wxPyEndAllowThreads(__tstate);
37340 if (PyErr_Occurred()) SWIG_fail;
37341 }
37342 {
37343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37344 }
37345 return resultobj;
37346 fail:
37347 return NULL;
37348 }
37349
37350
37351 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37352 PyObject *resultobj = 0;
37353 wxWindow *arg1 = (wxWindow *) 0 ;
37354 bool result;
37355 void *argp1 = 0 ;
37356 int res1 = 0 ;
37357 PyObject *swig_obj[1] ;
37358
37359 if (!args) SWIG_fail;
37360 swig_obj[0] = args;
37361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37362 if (!SWIG_IsOK(res1)) {
37363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37364 }
37365 arg1 = reinterpret_cast< wxWindow * >(argp1);
37366 {
37367 PyThreadState* __tstate = wxPyBeginAllowThreads();
37368 result = (bool)(arg1)->PageUp();
37369 wxPyEndAllowThreads(__tstate);
37370 if (PyErr_Occurred()) SWIG_fail;
37371 }
37372 {
37373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37374 }
37375 return resultobj;
37376 fail:
37377 return NULL;
37378 }
37379
37380
37381 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37382 PyObject *resultobj = 0;
37383 wxWindow *arg1 = (wxWindow *) 0 ;
37384 bool result;
37385 void *argp1 = 0 ;
37386 int res1 = 0 ;
37387 PyObject *swig_obj[1] ;
37388
37389 if (!args) SWIG_fail;
37390 swig_obj[0] = args;
37391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37392 if (!SWIG_IsOK(res1)) {
37393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37394 }
37395 arg1 = reinterpret_cast< wxWindow * >(argp1);
37396 {
37397 PyThreadState* __tstate = wxPyBeginAllowThreads();
37398 result = (bool)(arg1)->PageDown();
37399 wxPyEndAllowThreads(__tstate);
37400 if (PyErr_Occurred()) SWIG_fail;
37401 }
37402 {
37403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37404 }
37405 return resultobj;
37406 fail:
37407 return NULL;
37408 }
37409
37410
37411 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37412 PyObject *resultobj = 0;
37413 wxWindow *arg1 = (wxWindow *) 0 ;
37414 wxString *arg2 = 0 ;
37415 void *argp1 = 0 ;
37416 int res1 = 0 ;
37417 bool temp2 = false ;
37418 PyObject * obj0 = 0 ;
37419 PyObject * obj1 = 0 ;
37420 char * kwnames[] = {
37421 (char *) "self",(char *) "text", NULL
37422 };
37423
37424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37426 if (!SWIG_IsOK(res1)) {
37427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37428 }
37429 arg1 = reinterpret_cast< wxWindow * >(argp1);
37430 {
37431 arg2 = wxString_in_helper(obj1);
37432 if (arg2 == NULL) SWIG_fail;
37433 temp2 = true;
37434 }
37435 {
37436 PyThreadState* __tstate = wxPyBeginAllowThreads();
37437 (arg1)->SetHelpText((wxString const &)*arg2);
37438 wxPyEndAllowThreads(__tstate);
37439 if (PyErr_Occurred()) SWIG_fail;
37440 }
37441 resultobj = SWIG_Py_Void();
37442 {
37443 if (temp2)
37444 delete arg2;
37445 }
37446 return resultobj;
37447 fail:
37448 {
37449 if (temp2)
37450 delete arg2;
37451 }
37452 return NULL;
37453 }
37454
37455
37456 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37457 PyObject *resultobj = 0;
37458 wxWindow *arg1 = (wxWindow *) 0 ;
37459 wxString *arg2 = 0 ;
37460 void *argp1 = 0 ;
37461 int res1 = 0 ;
37462 bool temp2 = false ;
37463 PyObject * obj0 = 0 ;
37464 PyObject * obj1 = 0 ;
37465 char * kwnames[] = {
37466 (char *) "self",(char *) "text", NULL
37467 };
37468
37469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37471 if (!SWIG_IsOK(res1)) {
37472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37473 }
37474 arg1 = reinterpret_cast< wxWindow * >(argp1);
37475 {
37476 arg2 = wxString_in_helper(obj1);
37477 if (arg2 == NULL) SWIG_fail;
37478 temp2 = true;
37479 }
37480 {
37481 PyThreadState* __tstate = wxPyBeginAllowThreads();
37482 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37483 wxPyEndAllowThreads(__tstate);
37484 if (PyErr_Occurred()) SWIG_fail;
37485 }
37486 resultobj = SWIG_Py_Void();
37487 {
37488 if (temp2)
37489 delete arg2;
37490 }
37491 return resultobj;
37492 fail:
37493 {
37494 if (temp2)
37495 delete arg2;
37496 }
37497 return NULL;
37498 }
37499
37500
37501 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37502 PyObject *resultobj = 0;
37503 wxWindow *arg1 = (wxWindow *) 0 ;
37504 wxPoint *arg2 = 0 ;
37505 wxHelpEvent::Origin arg3 ;
37506 wxString result;
37507 void *argp1 = 0 ;
37508 int res1 = 0 ;
37509 wxPoint temp2 ;
37510 void *argp3 ;
37511 int res3 = 0 ;
37512 PyObject * obj0 = 0 ;
37513 PyObject * obj1 = 0 ;
37514 PyObject * obj2 = 0 ;
37515 char * kwnames[] = {
37516 (char *) "self",(char *) "pt",(char *) "origin", NULL
37517 };
37518
37519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37521 if (!SWIG_IsOK(res1)) {
37522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37523 }
37524 arg1 = reinterpret_cast< wxWindow * >(argp1);
37525 {
37526 arg2 = &temp2;
37527 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37528 }
37529 {
37530 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37531 if (!SWIG_IsOK(res3)) {
37532 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37533 }
37534 if (!argp3) {
37535 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37536 } else {
37537 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37538 arg3 = *temp;
37539 if (SWIG_IsNewObj(res3)) delete temp;
37540 }
37541 }
37542 {
37543 PyThreadState* __tstate = wxPyBeginAllowThreads();
37544 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37545 wxPyEndAllowThreads(__tstate);
37546 if (PyErr_Occurred()) SWIG_fail;
37547 }
37548 {
37549 #if wxUSE_UNICODE
37550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37551 #else
37552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37553 #endif
37554 }
37555 return resultobj;
37556 fail:
37557 return NULL;
37558 }
37559
37560
37561 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37562 PyObject *resultobj = 0;
37563 wxWindow *arg1 = (wxWindow *) 0 ;
37564 wxString result;
37565 void *argp1 = 0 ;
37566 int res1 = 0 ;
37567 PyObject *swig_obj[1] ;
37568
37569 if (!args) SWIG_fail;
37570 swig_obj[0] = args;
37571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37572 if (!SWIG_IsOK(res1)) {
37573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37574 }
37575 arg1 = reinterpret_cast< wxWindow * >(argp1);
37576 {
37577 PyThreadState* __tstate = wxPyBeginAllowThreads();
37578 result = ((wxWindow const *)arg1)->GetHelpText();
37579 wxPyEndAllowThreads(__tstate);
37580 if (PyErr_Occurred()) SWIG_fail;
37581 }
37582 {
37583 #if wxUSE_UNICODE
37584 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37585 #else
37586 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37587 #endif
37588 }
37589 return resultobj;
37590 fail:
37591 return NULL;
37592 }
37593
37594
37595 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37596 PyObject *resultobj = 0;
37597 wxWindow *arg1 = (wxWindow *) 0 ;
37598 wxString *arg2 = 0 ;
37599 void *argp1 = 0 ;
37600 int res1 = 0 ;
37601 bool temp2 = false ;
37602 PyObject * obj0 = 0 ;
37603 PyObject * obj1 = 0 ;
37604 char * kwnames[] = {
37605 (char *) "self",(char *) "tip", NULL
37606 };
37607
37608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37610 if (!SWIG_IsOK(res1)) {
37611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37612 }
37613 arg1 = reinterpret_cast< wxWindow * >(argp1);
37614 {
37615 arg2 = wxString_in_helper(obj1);
37616 if (arg2 == NULL) SWIG_fail;
37617 temp2 = true;
37618 }
37619 {
37620 PyThreadState* __tstate = wxPyBeginAllowThreads();
37621 (arg1)->SetToolTip((wxString const &)*arg2);
37622 wxPyEndAllowThreads(__tstate);
37623 if (PyErr_Occurred()) SWIG_fail;
37624 }
37625 resultobj = SWIG_Py_Void();
37626 {
37627 if (temp2)
37628 delete arg2;
37629 }
37630 return resultobj;
37631 fail:
37632 {
37633 if (temp2)
37634 delete arg2;
37635 }
37636 return NULL;
37637 }
37638
37639
37640 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37641 PyObject *resultobj = 0;
37642 wxWindow *arg1 = (wxWindow *) 0 ;
37643 wxToolTip *arg2 = (wxToolTip *) 0 ;
37644 void *argp1 = 0 ;
37645 int res1 = 0 ;
37646 int res2 = 0 ;
37647 PyObject * obj0 = 0 ;
37648 PyObject * obj1 = 0 ;
37649 char * kwnames[] = {
37650 (char *) "self",(char *) "tip", NULL
37651 };
37652
37653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37655 if (!SWIG_IsOK(res1)) {
37656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37657 }
37658 arg1 = reinterpret_cast< wxWindow * >(argp1);
37659 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37660 if (!SWIG_IsOK(res2)) {
37661 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37662 }
37663 {
37664 PyThreadState* __tstate = wxPyBeginAllowThreads();
37665 (arg1)->SetToolTip(arg2);
37666 wxPyEndAllowThreads(__tstate);
37667 if (PyErr_Occurred()) SWIG_fail;
37668 }
37669 resultobj = SWIG_Py_Void();
37670 return resultobj;
37671 fail:
37672 return NULL;
37673 }
37674
37675
37676 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37677 PyObject *resultobj = 0;
37678 wxWindow *arg1 = (wxWindow *) 0 ;
37679 wxToolTip *result = 0 ;
37680 void *argp1 = 0 ;
37681 int res1 = 0 ;
37682 PyObject *swig_obj[1] ;
37683
37684 if (!args) SWIG_fail;
37685 swig_obj[0] = args;
37686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37687 if (!SWIG_IsOK(res1)) {
37688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37689 }
37690 arg1 = reinterpret_cast< wxWindow * >(argp1);
37691 {
37692 PyThreadState* __tstate = wxPyBeginAllowThreads();
37693 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37694 wxPyEndAllowThreads(__tstate);
37695 if (PyErr_Occurred()) SWIG_fail;
37696 }
37697 {
37698 resultobj = wxPyMake_wxObject(result, (bool)0);
37699 }
37700 return resultobj;
37701 fail:
37702 return NULL;
37703 }
37704
37705
37706 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37707 PyObject *resultobj = 0;
37708 wxWindow *arg1 = (wxWindow *) 0 ;
37709 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37710 void *argp1 = 0 ;
37711 int res1 = 0 ;
37712 int res2 = 0 ;
37713 PyObject * obj0 = 0 ;
37714 PyObject * obj1 = 0 ;
37715 char * kwnames[] = {
37716 (char *) "self",(char *) "dropTarget", NULL
37717 };
37718
37719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37721 if (!SWIG_IsOK(res1)) {
37722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37723 }
37724 arg1 = reinterpret_cast< wxWindow * >(argp1);
37725 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37726 if (!SWIG_IsOK(res2)) {
37727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37728 }
37729 {
37730 PyThreadState* __tstate = wxPyBeginAllowThreads();
37731 (arg1)->SetDropTarget(arg2);
37732 wxPyEndAllowThreads(__tstate);
37733 if (PyErr_Occurred()) SWIG_fail;
37734 }
37735 resultobj = SWIG_Py_Void();
37736 return resultobj;
37737 fail:
37738 return NULL;
37739 }
37740
37741
37742 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37743 PyObject *resultobj = 0;
37744 wxWindow *arg1 = (wxWindow *) 0 ;
37745 wxPyDropTarget *result = 0 ;
37746 void *argp1 = 0 ;
37747 int res1 = 0 ;
37748 PyObject *swig_obj[1] ;
37749
37750 if (!args) SWIG_fail;
37751 swig_obj[0] = args;
37752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37753 if (!SWIG_IsOK(res1)) {
37754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37755 }
37756 arg1 = reinterpret_cast< wxWindow * >(argp1);
37757 {
37758 PyThreadState* __tstate = wxPyBeginAllowThreads();
37759 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37760 wxPyEndAllowThreads(__tstate);
37761 if (PyErr_Occurred()) SWIG_fail;
37762 }
37763 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37764 return resultobj;
37765 fail:
37766 return NULL;
37767 }
37768
37769
37770 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37771 PyObject *resultobj = 0;
37772 wxWindow *arg1 = (wxWindow *) 0 ;
37773 bool arg2 ;
37774 void *argp1 = 0 ;
37775 int res1 = 0 ;
37776 bool val2 ;
37777 int ecode2 = 0 ;
37778 PyObject * obj0 = 0 ;
37779 PyObject * obj1 = 0 ;
37780 char * kwnames[] = {
37781 (char *) "self",(char *) "accept", NULL
37782 };
37783
37784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37786 if (!SWIG_IsOK(res1)) {
37787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37788 }
37789 arg1 = reinterpret_cast< wxWindow * >(argp1);
37790 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37791 if (!SWIG_IsOK(ecode2)) {
37792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37793 }
37794 arg2 = static_cast< bool >(val2);
37795 {
37796 PyThreadState* __tstate = wxPyBeginAllowThreads();
37797 wxWindow_DragAcceptFiles(arg1,arg2);
37798 wxPyEndAllowThreads(__tstate);
37799 if (PyErr_Occurred()) SWIG_fail;
37800 }
37801 resultobj = SWIG_Py_Void();
37802 return resultobj;
37803 fail:
37804 return NULL;
37805 }
37806
37807
37808 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37809 PyObject *resultobj = 0;
37810 wxWindow *arg1 = (wxWindow *) 0 ;
37811 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37812 void *argp1 = 0 ;
37813 int res1 = 0 ;
37814 int res2 = 0 ;
37815 PyObject * obj0 = 0 ;
37816 PyObject * obj1 = 0 ;
37817 char * kwnames[] = {
37818 (char *) "self",(char *) "constraints", NULL
37819 };
37820
37821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37823 if (!SWIG_IsOK(res1)) {
37824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37825 }
37826 arg1 = reinterpret_cast< wxWindow * >(argp1);
37827 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37828 if (!SWIG_IsOK(res2)) {
37829 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37830 }
37831 {
37832 PyThreadState* __tstate = wxPyBeginAllowThreads();
37833 (arg1)->SetConstraints(arg2);
37834 wxPyEndAllowThreads(__tstate);
37835 if (PyErr_Occurred()) SWIG_fail;
37836 }
37837 resultobj = SWIG_Py_Void();
37838 return resultobj;
37839 fail:
37840 return NULL;
37841 }
37842
37843
37844 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37845 PyObject *resultobj = 0;
37846 wxWindow *arg1 = (wxWindow *) 0 ;
37847 wxLayoutConstraints *result = 0 ;
37848 void *argp1 = 0 ;
37849 int res1 = 0 ;
37850 PyObject *swig_obj[1] ;
37851
37852 if (!args) SWIG_fail;
37853 swig_obj[0] = args;
37854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37855 if (!SWIG_IsOK(res1)) {
37856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37857 }
37858 arg1 = reinterpret_cast< wxWindow * >(argp1);
37859 {
37860 PyThreadState* __tstate = wxPyBeginAllowThreads();
37861 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37862 wxPyEndAllowThreads(__tstate);
37863 if (PyErr_Occurred()) SWIG_fail;
37864 }
37865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37866 return resultobj;
37867 fail:
37868 return NULL;
37869 }
37870
37871
37872 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37873 PyObject *resultobj = 0;
37874 wxWindow *arg1 = (wxWindow *) 0 ;
37875 bool arg2 ;
37876 void *argp1 = 0 ;
37877 int res1 = 0 ;
37878 bool val2 ;
37879 int ecode2 = 0 ;
37880 PyObject * obj0 = 0 ;
37881 PyObject * obj1 = 0 ;
37882 char * kwnames[] = {
37883 (char *) "self",(char *) "autoLayout", NULL
37884 };
37885
37886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37888 if (!SWIG_IsOK(res1)) {
37889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37890 }
37891 arg1 = reinterpret_cast< wxWindow * >(argp1);
37892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37893 if (!SWIG_IsOK(ecode2)) {
37894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37895 }
37896 arg2 = static_cast< bool >(val2);
37897 {
37898 PyThreadState* __tstate = wxPyBeginAllowThreads();
37899 (arg1)->SetAutoLayout(arg2);
37900 wxPyEndAllowThreads(__tstate);
37901 if (PyErr_Occurred()) SWIG_fail;
37902 }
37903 resultobj = SWIG_Py_Void();
37904 return resultobj;
37905 fail:
37906 return NULL;
37907 }
37908
37909
37910 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37911 PyObject *resultobj = 0;
37912 wxWindow *arg1 = (wxWindow *) 0 ;
37913 bool result;
37914 void *argp1 = 0 ;
37915 int res1 = 0 ;
37916 PyObject *swig_obj[1] ;
37917
37918 if (!args) SWIG_fail;
37919 swig_obj[0] = args;
37920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37921 if (!SWIG_IsOK(res1)) {
37922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37923 }
37924 arg1 = reinterpret_cast< wxWindow * >(argp1);
37925 {
37926 PyThreadState* __tstate = wxPyBeginAllowThreads();
37927 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37928 wxPyEndAllowThreads(__tstate);
37929 if (PyErr_Occurred()) SWIG_fail;
37930 }
37931 {
37932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37933 }
37934 return resultobj;
37935 fail:
37936 return NULL;
37937 }
37938
37939
37940 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37941 PyObject *resultobj = 0;
37942 wxWindow *arg1 = (wxWindow *) 0 ;
37943 bool result;
37944 void *argp1 = 0 ;
37945 int res1 = 0 ;
37946 PyObject *swig_obj[1] ;
37947
37948 if (!args) SWIG_fail;
37949 swig_obj[0] = args;
37950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37951 if (!SWIG_IsOK(res1)) {
37952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37953 }
37954 arg1 = reinterpret_cast< wxWindow * >(argp1);
37955 {
37956 PyThreadState* __tstate = wxPyBeginAllowThreads();
37957 result = (bool)(arg1)->Layout();
37958 wxPyEndAllowThreads(__tstate);
37959 if (PyErr_Occurred()) SWIG_fail;
37960 }
37961 {
37962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37963 }
37964 return resultobj;
37965 fail:
37966 return NULL;
37967 }
37968
37969
37970 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37971 PyObject *resultobj = 0;
37972 wxWindow *arg1 = (wxWindow *) 0 ;
37973 wxSizer *arg2 = (wxSizer *) 0 ;
37974 bool arg3 = (bool) true ;
37975 void *argp1 = 0 ;
37976 int res1 = 0 ;
37977 int res2 = 0 ;
37978 bool val3 ;
37979 int ecode3 = 0 ;
37980 PyObject * obj0 = 0 ;
37981 PyObject * obj1 = 0 ;
37982 PyObject * obj2 = 0 ;
37983 char * kwnames[] = {
37984 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37985 };
37986
37987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37989 if (!SWIG_IsOK(res1)) {
37990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37991 }
37992 arg1 = reinterpret_cast< wxWindow * >(argp1);
37993 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37994 if (!SWIG_IsOK(res2)) {
37995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37996 }
37997 if (obj2) {
37998 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37999 if (!SWIG_IsOK(ecode3)) {
38000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38001 }
38002 arg3 = static_cast< bool >(val3);
38003 }
38004 {
38005 PyThreadState* __tstate = wxPyBeginAllowThreads();
38006 (arg1)->SetSizer(arg2,arg3);
38007 wxPyEndAllowThreads(__tstate);
38008 if (PyErr_Occurred()) SWIG_fail;
38009 }
38010 resultobj = SWIG_Py_Void();
38011 return resultobj;
38012 fail:
38013 return NULL;
38014 }
38015
38016
38017 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38018 PyObject *resultobj = 0;
38019 wxWindow *arg1 = (wxWindow *) 0 ;
38020 wxSizer *arg2 = (wxSizer *) 0 ;
38021 bool arg3 = (bool) true ;
38022 void *argp1 = 0 ;
38023 int res1 = 0 ;
38024 int res2 = 0 ;
38025 bool val3 ;
38026 int ecode3 = 0 ;
38027 PyObject * obj0 = 0 ;
38028 PyObject * obj1 = 0 ;
38029 PyObject * obj2 = 0 ;
38030 char * kwnames[] = {
38031 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38032 };
38033
38034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38036 if (!SWIG_IsOK(res1)) {
38037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38038 }
38039 arg1 = reinterpret_cast< wxWindow * >(argp1);
38040 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38041 if (!SWIG_IsOK(res2)) {
38042 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38043 }
38044 if (obj2) {
38045 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38046 if (!SWIG_IsOK(ecode3)) {
38047 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38048 }
38049 arg3 = static_cast< bool >(val3);
38050 }
38051 {
38052 PyThreadState* __tstate = wxPyBeginAllowThreads();
38053 (arg1)->SetSizerAndFit(arg2,arg3);
38054 wxPyEndAllowThreads(__tstate);
38055 if (PyErr_Occurred()) SWIG_fail;
38056 }
38057 resultobj = SWIG_Py_Void();
38058 return resultobj;
38059 fail:
38060 return NULL;
38061 }
38062
38063
38064 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38065 PyObject *resultobj = 0;
38066 wxWindow *arg1 = (wxWindow *) 0 ;
38067 wxSizer *result = 0 ;
38068 void *argp1 = 0 ;
38069 int res1 = 0 ;
38070 PyObject *swig_obj[1] ;
38071
38072 if (!args) SWIG_fail;
38073 swig_obj[0] = args;
38074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38075 if (!SWIG_IsOK(res1)) {
38076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38077 }
38078 arg1 = reinterpret_cast< wxWindow * >(argp1);
38079 {
38080 PyThreadState* __tstate = wxPyBeginAllowThreads();
38081 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38082 wxPyEndAllowThreads(__tstate);
38083 if (PyErr_Occurred()) SWIG_fail;
38084 }
38085 {
38086 resultobj = wxPyMake_wxObject(result, (bool)0);
38087 }
38088 return resultobj;
38089 fail:
38090 return NULL;
38091 }
38092
38093
38094 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38095 PyObject *resultobj = 0;
38096 wxWindow *arg1 = (wxWindow *) 0 ;
38097 wxSizer *arg2 = (wxSizer *) 0 ;
38098 void *argp1 = 0 ;
38099 int res1 = 0 ;
38100 void *argp2 = 0 ;
38101 int res2 = 0 ;
38102 PyObject * obj0 = 0 ;
38103 PyObject * obj1 = 0 ;
38104 char * kwnames[] = {
38105 (char *) "self",(char *) "sizer", NULL
38106 };
38107
38108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38110 if (!SWIG_IsOK(res1)) {
38111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38112 }
38113 arg1 = reinterpret_cast< wxWindow * >(argp1);
38114 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38115 if (!SWIG_IsOK(res2)) {
38116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38117 }
38118 arg2 = reinterpret_cast< wxSizer * >(argp2);
38119 {
38120 PyThreadState* __tstate = wxPyBeginAllowThreads();
38121 (arg1)->SetContainingSizer(arg2);
38122 wxPyEndAllowThreads(__tstate);
38123 if (PyErr_Occurred()) SWIG_fail;
38124 }
38125 resultobj = SWIG_Py_Void();
38126 return resultobj;
38127 fail:
38128 return NULL;
38129 }
38130
38131
38132 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38133 PyObject *resultobj = 0;
38134 wxWindow *arg1 = (wxWindow *) 0 ;
38135 wxSizer *result = 0 ;
38136 void *argp1 = 0 ;
38137 int res1 = 0 ;
38138 PyObject *swig_obj[1] ;
38139
38140 if (!args) SWIG_fail;
38141 swig_obj[0] = args;
38142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38143 if (!SWIG_IsOK(res1)) {
38144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38145 }
38146 arg1 = reinterpret_cast< wxWindow * >(argp1);
38147 {
38148 PyThreadState* __tstate = wxPyBeginAllowThreads();
38149 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38150 wxPyEndAllowThreads(__tstate);
38151 if (PyErr_Occurred()) SWIG_fail;
38152 }
38153 {
38154 resultobj = wxPyMake_wxObject(result, (bool)0);
38155 }
38156 return resultobj;
38157 fail:
38158 return NULL;
38159 }
38160
38161
38162 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38163 PyObject *resultobj = 0;
38164 wxWindow *arg1 = (wxWindow *) 0 ;
38165 void *argp1 = 0 ;
38166 int res1 = 0 ;
38167 PyObject *swig_obj[1] ;
38168
38169 if (!args) SWIG_fail;
38170 swig_obj[0] = args;
38171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38172 if (!SWIG_IsOK(res1)) {
38173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38174 }
38175 arg1 = reinterpret_cast< wxWindow * >(argp1);
38176 {
38177 PyThreadState* __tstate = wxPyBeginAllowThreads();
38178 (arg1)->InheritAttributes();
38179 wxPyEndAllowThreads(__tstate);
38180 if (PyErr_Occurred()) SWIG_fail;
38181 }
38182 resultobj = SWIG_Py_Void();
38183 return resultobj;
38184 fail:
38185 return NULL;
38186 }
38187
38188
38189 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38190 PyObject *resultobj = 0;
38191 wxWindow *arg1 = (wxWindow *) 0 ;
38192 bool result;
38193 void *argp1 = 0 ;
38194 int res1 = 0 ;
38195 PyObject *swig_obj[1] ;
38196
38197 if (!args) SWIG_fail;
38198 swig_obj[0] = args;
38199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38200 if (!SWIG_IsOK(res1)) {
38201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38202 }
38203 arg1 = reinterpret_cast< wxWindow * >(argp1);
38204 {
38205 PyThreadState* __tstate = wxPyBeginAllowThreads();
38206 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38207 wxPyEndAllowThreads(__tstate);
38208 if (PyErr_Occurred()) SWIG_fail;
38209 }
38210 {
38211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38212 }
38213 return resultobj;
38214 fail:
38215 return NULL;
38216 }
38217
38218
38219 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38220 PyObject *resultobj = 0;
38221 wxWindow *arg1 = (wxWindow *) 0 ;
38222 bool result;
38223 void *argp1 = 0 ;
38224 int res1 = 0 ;
38225 PyObject *swig_obj[1] ;
38226
38227 if (!args) SWIG_fail;
38228 swig_obj[0] = args;
38229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38230 if (!SWIG_IsOK(res1)) {
38231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38232 }
38233 arg1 = reinterpret_cast< wxWindow * >(argp1);
38234 {
38235 PyThreadState* __tstate = wxPyBeginAllowThreads();
38236 result = (bool)(arg1)->CanSetTransparent();
38237 wxPyEndAllowThreads(__tstate);
38238 if (PyErr_Occurred()) SWIG_fail;
38239 }
38240 {
38241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38242 }
38243 return resultobj;
38244 fail:
38245 return NULL;
38246 }
38247
38248
38249 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38250 PyObject *resultobj = 0;
38251 wxWindow *arg1 = (wxWindow *) 0 ;
38252 byte arg2 ;
38253 bool result;
38254 void *argp1 = 0 ;
38255 int res1 = 0 ;
38256 unsigned char val2 ;
38257 int ecode2 = 0 ;
38258 PyObject * obj0 = 0 ;
38259 PyObject * obj1 = 0 ;
38260 char * kwnames[] = {
38261 (char *) "self",(char *) "alpha", NULL
38262 };
38263
38264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38266 if (!SWIG_IsOK(res1)) {
38267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38268 }
38269 arg1 = reinterpret_cast< wxWindow * >(argp1);
38270 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38271 if (!SWIG_IsOK(ecode2)) {
38272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38273 }
38274 arg2 = static_cast< byte >(val2);
38275 {
38276 PyThreadState* __tstate = wxPyBeginAllowThreads();
38277 result = (bool)(arg1)->SetTransparent(arg2);
38278 wxPyEndAllowThreads(__tstate);
38279 if (PyErr_Occurred()) SWIG_fail;
38280 }
38281 {
38282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38283 }
38284 return resultobj;
38285 fail:
38286 return NULL;
38287 }
38288
38289
38290 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38291 PyObject *obj;
38292 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38293 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38294 return SWIG_Py_Void();
38295 }
38296
38297 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38298 return SWIG_Python_InitShadowInstance(args);
38299 }
38300
38301 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38302 PyObject *resultobj = 0;
38303 long arg1 ;
38304 wxWindow *arg2 = (wxWindow *) NULL ;
38305 wxWindow *result = 0 ;
38306 long val1 ;
38307 int ecode1 = 0 ;
38308 void *argp2 = 0 ;
38309 int res2 = 0 ;
38310 PyObject * obj0 = 0 ;
38311 PyObject * obj1 = 0 ;
38312 char * kwnames[] = {
38313 (char *) "id",(char *) "parent", NULL
38314 };
38315
38316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38317 ecode1 = SWIG_AsVal_long(obj0, &val1);
38318 if (!SWIG_IsOK(ecode1)) {
38319 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38320 }
38321 arg1 = static_cast< long >(val1);
38322 if (obj1) {
38323 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38324 if (!SWIG_IsOK(res2)) {
38325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38326 }
38327 arg2 = reinterpret_cast< wxWindow * >(argp2);
38328 }
38329 {
38330 if (!wxPyCheckForApp()) SWIG_fail;
38331 PyThreadState* __tstate = wxPyBeginAllowThreads();
38332 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38333 wxPyEndAllowThreads(__tstate);
38334 if (PyErr_Occurred()) SWIG_fail;
38335 }
38336 {
38337 resultobj = wxPyMake_wxObject(result, 0);
38338 }
38339 return resultobj;
38340 fail:
38341 return NULL;
38342 }
38343
38344
38345 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38346 PyObject *resultobj = 0;
38347 wxString *arg1 = 0 ;
38348 wxWindow *arg2 = (wxWindow *) NULL ;
38349 wxWindow *result = 0 ;
38350 bool temp1 = false ;
38351 void *argp2 = 0 ;
38352 int res2 = 0 ;
38353 PyObject * obj0 = 0 ;
38354 PyObject * obj1 = 0 ;
38355 char * kwnames[] = {
38356 (char *) "name",(char *) "parent", NULL
38357 };
38358
38359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38360 {
38361 arg1 = wxString_in_helper(obj0);
38362 if (arg1 == NULL) SWIG_fail;
38363 temp1 = true;
38364 }
38365 if (obj1) {
38366 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38367 if (!SWIG_IsOK(res2)) {
38368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38369 }
38370 arg2 = reinterpret_cast< wxWindow * >(argp2);
38371 }
38372 {
38373 if (!wxPyCheckForApp()) SWIG_fail;
38374 PyThreadState* __tstate = wxPyBeginAllowThreads();
38375 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38376 wxPyEndAllowThreads(__tstate);
38377 if (PyErr_Occurred()) SWIG_fail;
38378 }
38379 {
38380 resultobj = wxPyMake_wxObject(result, 0);
38381 }
38382 {
38383 if (temp1)
38384 delete arg1;
38385 }
38386 return resultobj;
38387 fail:
38388 {
38389 if (temp1)
38390 delete arg1;
38391 }
38392 return NULL;
38393 }
38394
38395
38396 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38397 PyObject *resultobj = 0;
38398 wxString *arg1 = 0 ;
38399 wxWindow *arg2 = (wxWindow *) NULL ;
38400 wxWindow *result = 0 ;
38401 bool temp1 = false ;
38402 void *argp2 = 0 ;
38403 int res2 = 0 ;
38404 PyObject * obj0 = 0 ;
38405 PyObject * obj1 = 0 ;
38406 char * kwnames[] = {
38407 (char *) "label",(char *) "parent", NULL
38408 };
38409
38410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38411 {
38412 arg1 = wxString_in_helper(obj0);
38413 if (arg1 == NULL) SWIG_fail;
38414 temp1 = true;
38415 }
38416 if (obj1) {
38417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38418 if (!SWIG_IsOK(res2)) {
38419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38420 }
38421 arg2 = reinterpret_cast< wxWindow * >(argp2);
38422 }
38423 {
38424 if (!wxPyCheckForApp()) SWIG_fail;
38425 PyThreadState* __tstate = wxPyBeginAllowThreads();
38426 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38427 wxPyEndAllowThreads(__tstate);
38428 if (PyErr_Occurred()) SWIG_fail;
38429 }
38430 {
38431 resultobj = wxPyMake_wxObject(result, 0);
38432 }
38433 {
38434 if (temp1)
38435 delete arg1;
38436 }
38437 return resultobj;
38438 fail:
38439 {
38440 if (temp1)
38441 delete arg1;
38442 }
38443 return NULL;
38444 }
38445
38446
38447 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38448 PyObject *resultobj = 0;
38449 wxWindow *arg1 = (wxWindow *) 0 ;
38450 unsigned long arg2 ;
38451 wxWindow *result = 0 ;
38452 void *argp1 = 0 ;
38453 int res1 = 0 ;
38454 unsigned long val2 ;
38455 int ecode2 = 0 ;
38456 PyObject * obj0 = 0 ;
38457 PyObject * obj1 = 0 ;
38458 char * kwnames[] = {
38459 (char *) "parent",(char *) "_hWnd", NULL
38460 };
38461
38462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38464 if (!SWIG_IsOK(res1)) {
38465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38466 }
38467 arg1 = reinterpret_cast< wxWindow * >(argp1);
38468 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38469 if (!SWIG_IsOK(ecode2)) {
38470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38471 }
38472 arg2 = static_cast< unsigned long >(val2);
38473 {
38474 PyThreadState* __tstate = wxPyBeginAllowThreads();
38475 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38476 wxPyEndAllowThreads(__tstate);
38477 if (PyErr_Occurred()) SWIG_fail;
38478 }
38479 {
38480 resultobj = wxPyMake_wxObject(result, 0);
38481 }
38482 return resultobj;
38483 fail:
38484 return NULL;
38485 }
38486
38487
38488 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38489 PyObject *resultobj = 0;
38490 PyObject *result = 0 ;
38491
38492 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38493 {
38494 PyThreadState* __tstate = wxPyBeginAllowThreads();
38495 result = (PyObject *)GetTopLevelWindows();
38496 wxPyEndAllowThreads(__tstate);
38497 if (PyErr_Occurred()) SWIG_fail;
38498 }
38499 resultobj = result;
38500 return resultobj;
38501 fail:
38502 return NULL;
38503 }
38504
38505
38506 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38507 PyObject *resultobj = 0;
38508 wxValidator *result = 0 ;
38509
38510 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38511 {
38512 PyThreadState* __tstate = wxPyBeginAllowThreads();
38513 result = (wxValidator *)new wxValidator();
38514 wxPyEndAllowThreads(__tstate);
38515 if (PyErr_Occurred()) SWIG_fail;
38516 }
38517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38518 return resultobj;
38519 fail:
38520 return NULL;
38521 }
38522
38523
38524 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38525 PyObject *resultobj = 0;
38526 wxValidator *arg1 = (wxValidator *) 0 ;
38527 wxValidator *result = 0 ;
38528 void *argp1 = 0 ;
38529 int res1 = 0 ;
38530 PyObject *swig_obj[1] ;
38531
38532 if (!args) SWIG_fail;
38533 swig_obj[0] = args;
38534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38535 if (!SWIG_IsOK(res1)) {
38536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38537 }
38538 arg1 = reinterpret_cast< wxValidator * >(argp1);
38539 {
38540 PyThreadState* __tstate = wxPyBeginAllowThreads();
38541 result = (wxValidator *)(arg1)->Clone();
38542 wxPyEndAllowThreads(__tstate);
38543 if (PyErr_Occurred()) SWIG_fail;
38544 }
38545 {
38546 resultobj = wxPyMake_wxObject(result, 0);
38547 }
38548 return resultobj;
38549 fail:
38550 return NULL;
38551 }
38552
38553
38554 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38555 PyObject *resultobj = 0;
38556 wxValidator *arg1 = (wxValidator *) 0 ;
38557 wxWindow *arg2 = (wxWindow *) 0 ;
38558 bool result;
38559 void *argp1 = 0 ;
38560 int res1 = 0 ;
38561 void *argp2 = 0 ;
38562 int res2 = 0 ;
38563 PyObject * obj0 = 0 ;
38564 PyObject * obj1 = 0 ;
38565 char * kwnames[] = {
38566 (char *) "self",(char *) "parent", NULL
38567 };
38568
38569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38571 if (!SWIG_IsOK(res1)) {
38572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38573 }
38574 arg1 = reinterpret_cast< wxValidator * >(argp1);
38575 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38576 if (!SWIG_IsOK(res2)) {
38577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38578 }
38579 arg2 = reinterpret_cast< wxWindow * >(argp2);
38580 {
38581 PyThreadState* __tstate = wxPyBeginAllowThreads();
38582 result = (bool)(arg1)->Validate(arg2);
38583 wxPyEndAllowThreads(__tstate);
38584 if (PyErr_Occurred()) SWIG_fail;
38585 }
38586 {
38587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38588 }
38589 return resultobj;
38590 fail:
38591 return NULL;
38592 }
38593
38594
38595 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38596 PyObject *resultobj = 0;
38597 wxValidator *arg1 = (wxValidator *) 0 ;
38598 bool result;
38599 void *argp1 = 0 ;
38600 int res1 = 0 ;
38601 PyObject *swig_obj[1] ;
38602
38603 if (!args) SWIG_fail;
38604 swig_obj[0] = args;
38605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38606 if (!SWIG_IsOK(res1)) {
38607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38608 }
38609 arg1 = reinterpret_cast< wxValidator * >(argp1);
38610 {
38611 PyThreadState* __tstate = wxPyBeginAllowThreads();
38612 result = (bool)(arg1)->TransferToWindow();
38613 wxPyEndAllowThreads(__tstate);
38614 if (PyErr_Occurred()) SWIG_fail;
38615 }
38616 {
38617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38618 }
38619 return resultobj;
38620 fail:
38621 return NULL;
38622 }
38623
38624
38625 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38626 PyObject *resultobj = 0;
38627 wxValidator *arg1 = (wxValidator *) 0 ;
38628 bool result;
38629 void *argp1 = 0 ;
38630 int res1 = 0 ;
38631 PyObject *swig_obj[1] ;
38632
38633 if (!args) SWIG_fail;
38634 swig_obj[0] = args;
38635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38636 if (!SWIG_IsOK(res1)) {
38637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38638 }
38639 arg1 = reinterpret_cast< wxValidator * >(argp1);
38640 {
38641 PyThreadState* __tstate = wxPyBeginAllowThreads();
38642 result = (bool)(arg1)->TransferFromWindow();
38643 wxPyEndAllowThreads(__tstate);
38644 if (PyErr_Occurred()) SWIG_fail;
38645 }
38646 {
38647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38648 }
38649 return resultobj;
38650 fail:
38651 return NULL;
38652 }
38653
38654
38655 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38656 PyObject *resultobj = 0;
38657 wxValidator *arg1 = (wxValidator *) 0 ;
38658 wxWindow *result = 0 ;
38659 void *argp1 = 0 ;
38660 int res1 = 0 ;
38661 PyObject *swig_obj[1] ;
38662
38663 if (!args) SWIG_fail;
38664 swig_obj[0] = args;
38665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38666 if (!SWIG_IsOK(res1)) {
38667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38668 }
38669 arg1 = reinterpret_cast< wxValidator * >(argp1);
38670 {
38671 PyThreadState* __tstate = wxPyBeginAllowThreads();
38672 result = (wxWindow *)(arg1)->GetWindow();
38673 wxPyEndAllowThreads(__tstate);
38674 if (PyErr_Occurred()) SWIG_fail;
38675 }
38676 {
38677 resultobj = wxPyMake_wxObject(result, 0);
38678 }
38679 return resultobj;
38680 fail:
38681 return NULL;
38682 }
38683
38684
38685 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38686 PyObject *resultobj = 0;
38687 wxValidator *arg1 = (wxValidator *) 0 ;
38688 wxWindow *arg2 = (wxWindow *) 0 ;
38689 void *argp1 = 0 ;
38690 int res1 = 0 ;
38691 void *argp2 = 0 ;
38692 int res2 = 0 ;
38693 PyObject * obj0 = 0 ;
38694 PyObject * obj1 = 0 ;
38695 char * kwnames[] = {
38696 (char *) "self",(char *) "window", NULL
38697 };
38698
38699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38701 if (!SWIG_IsOK(res1)) {
38702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38703 }
38704 arg1 = reinterpret_cast< wxValidator * >(argp1);
38705 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38706 if (!SWIG_IsOK(res2)) {
38707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38708 }
38709 arg2 = reinterpret_cast< wxWindow * >(argp2);
38710 {
38711 PyThreadState* __tstate = wxPyBeginAllowThreads();
38712 (arg1)->SetWindow(arg2);
38713 wxPyEndAllowThreads(__tstate);
38714 if (PyErr_Occurred()) SWIG_fail;
38715 }
38716 resultobj = SWIG_Py_Void();
38717 return resultobj;
38718 fail:
38719 return NULL;
38720 }
38721
38722
38723 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38724 PyObject *resultobj = 0;
38725 bool result;
38726
38727 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38728 {
38729 PyThreadState* __tstate = wxPyBeginAllowThreads();
38730 result = (bool)wxValidator::IsSilent();
38731 wxPyEndAllowThreads(__tstate);
38732 if (PyErr_Occurred()) SWIG_fail;
38733 }
38734 {
38735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38736 }
38737 return resultobj;
38738 fail:
38739 return NULL;
38740 }
38741
38742
38743 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38744 PyObject *resultobj = 0;
38745 int arg1 = (int) true ;
38746 int val1 ;
38747 int ecode1 = 0 ;
38748 PyObject * obj0 = 0 ;
38749 char * kwnames[] = {
38750 (char *) "doIt", NULL
38751 };
38752
38753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38754 if (obj0) {
38755 ecode1 = SWIG_AsVal_int(obj0, &val1);
38756 if (!SWIG_IsOK(ecode1)) {
38757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38758 }
38759 arg1 = static_cast< int >(val1);
38760 }
38761 {
38762 PyThreadState* __tstate = wxPyBeginAllowThreads();
38763 wxValidator::SetBellOnError(arg1);
38764 wxPyEndAllowThreads(__tstate);
38765 if (PyErr_Occurred()) SWIG_fail;
38766 }
38767 resultobj = SWIG_Py_Void();
38768 return resultobj;
38769 fail:
38770 return NULL;
38771 }
38772
38773
38774 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38775 PyObject *obj;
38776 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38777 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38778 return SWIG_Py_Void();
38779 }
38780
38781 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38782 return SWIG_Python_InitShadowInstance(args);
38783 }
38784
38785 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38786 PyObject *resultobj = 0;
38787 wxPyValidator *result = 0 ;
38788
38789 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38790 {
38791 PyThreadState* __tstate = wxPyBeginAllowThreads();
38792 result = (wxPyValidator *)new wxPyValidator();
38793 wxPyEndAllowThreads(__tstate);
38794 if (PyErr_Occurred()) SWIG_fail;
38795 }
38796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38797 return resultobj;
38798 fail:
38799 return NULL;
38800 }
38801
38802
38803 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38804 PyObject *resultobj = 0;
38805 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38806 PyObject *arg2 = (PyObject *) 0 ;
38807 PyObject *arg3 = (PyObject *) 0 ;
38808 int arg4 = (int) true ;
38809 void *argp1 = 0 ;
38810 int res1 = 0 ;
38811 int val4 ;
38812 int ecode4 = 0 ;
38813 PyObject * obj0 = 0 ;
38814 PyObject * obj1 = 0 ;
38815 PyObject * obj2 = 0 ;
38816 PyObject * obj3 = 0 ;
38817 char * kwnames[] = {
38818 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38819 };
38820
38821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38823 if (!SWIG_IsOK(res1)) {
38824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38825 }
38826 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38827 arg2 = obj1;
38828 arg3 = obj2;
38829 if (obj3) {
38830 ecode4 = SWIG_AsVal_int(obj3, &val4);
38831 if (!SWIG_IsOK(ecode4)) {
38832 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38833 }
38834 arg4 = static_cast< int >(val4);
38835 }
38836 {
38837 PyThreadState* __tstate = wxPyBeginAllowThreads();
38838 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38839 wxPyEndAllowThreads(__tstate);
38840 if (PyErr_Occurred()) SWIG_fail;
38841 }
38842 resultobj = SWIG_Py_Void();
38843 return resultobj;
38844 fail:
38845 return NULL;
38846 }
38847
38848
38849 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38850 PyObject *obj;
38851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38852 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38853 return SWIG_Py_Void();
38854 }
38855
38856 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38857 return SWIG_Python_InitShadowInstance(args);
38858 }
38859
38860 SWIGINTERN int DefaultValidator_set(PyObject *) {
38861 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38862 return 1;
38863 }
38864
38865
38866 SWIGINTERN PyObject *DefaultValidator_get(void) {
38867 PyObject *pyobj = 0;
38868
38869 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38870 return pyobj;
38871 }
38872
38873
38874 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38875 PyObject *resultobj = 0;
38876 wxString const &arg1_defvalue = wxPyEmptyString ;
38877 wxString *arg1 = (wxString *) &arg1_defvalue ;
38878 long arg2 = (long) 0 ;
38879 wxMenu *result = 0 ;
38880 bool temp1 = false ;
38881 long val2 ;
38882 int ecode2 = 0 ;
38883 PyObject * obj0 = 0 ;
38884 PyObject * obj1 = 0 ;
38885 char * kwnames[] = {
38886 (char *) "title",(char *) "style", NULL
38887 };
38888
38889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38890 if (obj0) {
38891 {
38892 arg1 = wxString_in_helper(obj0);
38893 if (arg1 == NULL) SWIG_fail;
38894 temp1 = true;
38895 }
38896 }
38897 if (obj1) {
38898 ecode2 = SWIG_AsVal_long(obj1, &val2);
38899 if (!SWIG_IsOK(ecode2)) {
38900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38901 }
38902 arg2 = static_cast< long >(val2);
38903 }
38904 {
38905 if (!wxPyCheckForApp()) SWIG_fail;
38906 PyThreadState* __tstate = wxPyBeginAllowThreads();
38907 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38908 wxPyEndAllowThreads(__tstate);
38909 if (PyErr_Occurred()) SWIG_fail;
38910 }
38911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38912 {
38913 if (temp1)
38914 delete arg1;
38915 }
38916 return resultobj;
38917 fail:
38918 {
38919 if (temp1)
38920 delete arg1;
38921 }
38922 return NULL;
38923 }
38924
38925
38926 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38927 PyObject *resultobj = 0;
38928 wxMenu *arg1 = (wxMenu *) 0 ;
38929 int arg2 ;
38930 wxString const &arg3_defvalue = wxPyEmptyString ;
38931 wxString *arg3 = (wxString *) &arg3_defvalue ;
38932 wxString const &arg4_defvalue = wxPyEmptyString ;
38933 wxString *arg4 = (wxString *) &arg4_defvalue ;
38934 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38935 wxMenuItem *result = 0 ;
38936 void *argp1 = 0 ;
38937 int res1 = 0 ;
38938 int val2 ;
38939 int ecode2 = 0 ;
38940 bool temp3 = false ;
38941 bool temp4 = false ;
38942 int val5 ;
38943 int ecode5 = 0 ;
38944 PyObject * obj0 = 0 ;
38945 PyObject * obj1 = 0 ;
38946 PyObject * obj2 = 0 ;
38947 PyObject * obj3 = 0 ;
38948 PyObject * obj4 = 0 ;
38949 char * kwnames[] = {
38950 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38951 };
38952
38953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38955 if (!SWIG_IsOK(res1)) {
38956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38957 }
38958 arg1 = reinterpret_cast< wxMenu * >(argp1);
38959 ecode2 = SWIG_AsVal_int(obj1, &val2);
38960 if (!SWIG_IsOK(ecode2)) {
38961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38962 }
38963 arg2 = static_cast< int >(val2);
38964 if (obj2) {
38965 {
38966 arg3 = wxString_in_helper(obj2);
38967 if (arg3 == NULL) SWIG_fail;
38968 temp3 = true;
38969 }
38970 }
38971 if (obj3) {
38972 {
38973 arg4 = wxString_in_helper(obj3);
38974 if (arg4 == NULL) SWIG_fail;
38975 temp4 = true;
38976 }
38977 }
38978 if (obj4) {
38979 ecode5 = SWIG_AsVal_int(obj4, &val5);
38980 if (!SWIG_IsOK(ecode5)) {
38981 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38982 }
38983 arg5 = static_cast< wxItemKind >(val5);
38984 }
38985 {
38986 PyThreadState* __tstate = wxPyBeginAllowThreads();
38987 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38988 wxPyEndAllowThreads(__tstate);
38989 if (PyErr_Occurred()) SWIG_fail;
38990 }
38991 {
38992 resultobj = wxPyMake_wxObject(result, (bool)0);
38993 }
38994 {
38995 if (temp3)
38996 delete arg3;
38997 }
38998 {
38999 if (temp4)
39000 delete arg4;
39001 }
39002 return resultobj;
39003 fail:
39004 {
39005 if (temp3)
39006 delete arg3;
39007 }
39008 {
39009 if (temp4)
39010 delete arg4;
39011 }
39012 return NULL;
39013 }
39014
39015
39016 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39017 PyObject *resultobj = 0;
39018 wxMenu *arg1 = (wxMenu *) 0 ;
39019 wxMenuItem *result = 0 ;
39020 void *argp1 = 0 ;
39021 int res1 = 0 ;
39022 PyObject *swig_obj[1] ;
39023
39024 if (!args) SWIG_fail;
39025 swig_obj[0] = args;
39026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39027 if (!SWIG_IsOK(res1)) {
39028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39029 }
39030 arg1 = reinterpret_cast< wxMenu * >(argp1);
39031 {
39032 PyThreadState* __tstate = wxPyBeginAllowThreads();
39033 result = (wxMenuItem *)(arg1)->AppendSeparator();
39034 wxPyEndAllowThreads(__tstate);
39035 if (PyErr_Occurred()) SWIG_fail;
39036 }
39037 {
39038 resultobj = wxPyMake_wxObject(result, (bool)0);
39039 }
39040 return resultobj;
39041 fail:
39042 return NULL;
39043 }
39044
39045
39046 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39047 PyObject *resultobj = 0;
39048 wxMenu *arg1 = (wxMenu *) 0 ;
39049 int arg2 ;
39050 wxString *arg3 = 0 ;
39051 wxString const &arg4_defvalue = wxPyEmptyString ;
39052 wxString *arg4 = (wxString *) &arg4_defvalue ;
39053 wxMenuItem *result = 0 ;
39054 void *argp1 = 0 ;
39055 int res1 = 0 ;
39056 int val2 ;
39057 int ecode2 = 0 ;
39058 bool temp3 = false ;
39059 bool temp4 = false ;
39060 PyObject * obj0 = 0 ;
39061 PyObject * obj1 = 0 ;
39062 PyObject * obj2 = 0 ;
39063 PyObject * obj3 = 0 ;
39064 char * kwnames[] = {
39065 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39066 };
39067
39068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39070 if (!SWIG_IsOK(res1)) {
39071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39072 }
39073 arg1 = reinterpret_cast< wxMenu * >(argp1);
39074 ecode2 = SWIG_AsVal_int(obj1, &val2);
39075 if (!SWIG_IsOK(ecode2)) {
39076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39077 }
39078 arg2 = static_cast< int >(val2);
39079 {
39080 arg3 = wxString_in_helper(obj2);
39081 if (arg3 == NULL) SWIG_fail;
39082 temp3 = true;
39083 }
39084 if (obj3) {
39085 {
39086 arg4 = wxString_in_helper(obj3);
39087 if (arg4 == NULL) SWIG_fail;
39088 temp4 = true;
39089 }
39090 }
39091 {
39092 PyThreadState* __tstate = wxPyBeginAllowThreads();
39093 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39094 wxPyEndAllowThreads(__tstate);
39095 if (PyErr_Occurred()) SWIG_fail;
39096 }
39097 {
39098 resultobj = wxPyMake_wxObject(result, (bool)0);
39099 }
39100 {
39101 if (temp3)
39102 delete arg3;
39103 }
39104 {
39105 if (temp4)
39106 delete arg4;
39107 }
39108 return resultobj;
39109 fail:
39110 {
39111 if (temp3)
39112 delete arg3;
39113 }
39114 {
39115 if (temp4)
39116 delete arg4;
39117 }
39118 return NULL;
39119 }
39120
39121
39122 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(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_AppendRadioItem",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_AppendRadioItem" "', 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_AppendRadioItem" "', 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)->AppendRadioItem(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_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39199 PyObject *resultobj = 0;
39200 wxMenu *arg1 = (wxMenu *) 0 ;
39201 int arg2 ;
39202 wxString *arg3 = 0 ;
39203 wxMenu *arg4 = (wxMenu *) 0 ;
39204 wxString const &arg5_defvalue = wxPyEmptyString ;
39205 wxString *arg5 = (wxString *) &arg5_defvalue ;
39206 wxMenuItem *result = 0 ;
39207 void *argp1 = 0 ;
39208 int res1 = 0 ;
39209 int val2 ;
39210 int ecode2 = 0 ;
39211 bool temp3 = false ;
39212 void *argp4 = 0 ;
39213 int res4 = 0 ;
39214 bool temp5 = false ;
39215 PyObject * obj0 = 0 ;
39216 PyObject * obj1 = 0 ;
39217 PyObject * obj2 = 0 ;
39218 PyObject * obj3 = 0 ;
39219 PyObject * obj4 = 0 ;
39220 char * kwnames[] = {
39221 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39222 };
39223
39224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39226 if (!SWIG_IsOK(res1)) {
39227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39228 }
39229 arg1 = reinterpret_cast< wxMenu * >(argp1);
39230 ecode2 = SWIG_AsVal_int(obj1, &val2);
39231 if (!SWIG_IsOK(ecode2)) {
39232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39233 }
39234 arg2 = static_cast< int >(val2);
39235 {
39236 arg3 = wxString_in_helper(obj2);
39237 if (arg3 == NULL) SWIG_fail;
39238 temp3 = true;
39239 }
39240 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39241 if (!SWIG_IsOK(res4)) {
39242 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39243 }
39244 arg4 = reinterpret_cast< wxMenu * >(argp4);
39245 if (obj4) {
39246 {
39247 arg5 = wxString_in_helper(obj4);
39248 if (arg5 == NULL) SWIG_fail;
39249 temp5 = true;
39250 }
39251 }
39252 {
39253 PyThreadState* __tstate = wxPyBeginAllowThreads();
39254 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39255 wxPyEndAllowThreads(__tstate);
39256 if (PyErr_Occurred()) SWIG_fail;
39257 }
39258 {
39259 resultobj = wxPyMake_wxObject(result, (bool)0);
39260 }
39261 {
39262 if (temp3)
39263 delete arg3;
39264 }
39265 {
39266 if (temp5)
39267 delete arg5;
39268 }
39269 return resultobj;
39270 fail:
39271 {
39272 if (temp3)
39273 delete arg3;
39274 }
39275 {
39276 if (temp5)
39277 delete arg5;
39278 }
39279 return NULL;
39280 }
39281
39282
39283 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39284 PyObject *resultobj = 0;
39285 wxMenu *arg1 = (wxMenu *) 0 ;
39286 wxMenu *arg2 = (wxMenu *) 0 ;
39287 wxString *arg3 = 0 ;
39288 wxString const &arg4_defvalue = wxPyEmptyString ;
39289 wxString *arg4 = (wxString *) &arg4_defvalue ;
39290 wxMenuItem *result = 0 ;
39291 void *argp1 = 0 ;
39292 int res1 = 0 ;
39293 void *argp2 = 0 ;
39294 int res2 = 0 ;
39295 bool temp3 = false ;
39296 bool temp4 = false ;
39297 PyObject * obj0 = 0 ;
39298 PyObject * obj1 = 0 ;
39299 PyObject * obj2 = 0 ;
39300 PyObject * obj3 = 0 ;
39301 char * kwnames[] = {
39302 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39303 };
39304
39305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39307 if (!SWIG_IsOK(res1)) {
39308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39309 }
39310 arg1 = reinterpret_cast< wxMenu * >(argp1);
39311 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39312 if (!SWIG_IsOK(res2)) {
39313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39314 }
39315 arg2 = reinterpret_cast< wxMenu * >(argp2);
39316 {
39317 arg3 = wxString_in_helper(obj2);
39318 if (arg3 == NULL) SWIG_fail;
39319 temp3 = true;
39320 }
39321 if (obj3) {
39322 {
39323 arg4 = wxString_in_helper(obj3);
39324 if (arg4 == NULL) SWIG_fail;
39325 temp4 = true;
39326 }
39327 }
39328 {
39329 PyThreadState* __tstate = wxPyBeginAllowThreads();
39330 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
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 (temp4)
39343 delete arg4;
39344 }
39345 return resultobj;
39346 fail:
39347 {
39348 if (temp3)
39349 delete arg3;
39350 }
39351 {
39352 if (temp4)
39353 delete arg4;
39354 }
39355 return NULL;
39356 }
39357
39358
39359 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39360 PyObject *resultobj = 0;
39361 wxMenu *arg1 = (wxMenu *) 0 ;
39362 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39363 wxMenuItem *result = 0 ;
39364 void *argp1 = 0 ;
39365 int res1 = 0 ;
39366 int res2 = 0 ;
39367 PyObject * obj0 = 0 ;
39368 PyObject * obj1 = 0 ;
39369 char * kwnames[] = {
39370 (char *) "self",(char *) "item", NULL
39371 };
39372
39373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39375 if (!SWIG_IsOK(res1)) {
39376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39377 }
39378 arg1 = reinterpret_cast< wxMenu * >(argp1);
39379 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39380 if (!SWIG_IsOK(res2)) {
39381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39382 }
39383 {
39384 PyThreadState* __tstate = wxPyBeginAllowThreads();
39385 result = (wxMenuItem *)(arg1)->Append(arg2);
39386 wxPyEndAllowThreads(__tstate);
39387 if (PyErr_Occurred()) SWIG_fail;
39388 }
39389 {
39390 resultobj = wxPyMake_wxObject(result, (bool)0);
39391 }
39392 return resultobj;
39393 fail:
39394 return NULL;
39395 }
39396
39397
39398 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39399 PyObject *resultobj = 0;
39400 wxMenu *arg1 = (wxMenu *) 0 ;
39401 size_t arg2 ;
39402 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39403 wxMenuItem *result = 0 ;
39404 void *argp1 = 0 ;
39405 int res1 = 0 ;
39406 size_t val2 ;
39407 int ecode2 = 0 ;
39408 int res3 = 0 ;
39409 PyObject * obj0 = 0 ;
39410 PyObject * obj1 = 0 ;
39411 PyObject * obj2 = 0 ;
39412 char * kwnames[] = {
39413 (char *) "self",(char *) "pos",(char *) "item", NULL
39414 };
39415
39416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39418 if (!SWIG_IsOK(res1)) {
39419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39420 }
39421 arg1 = reinterpret_cast< wxMenu * >(argp1);
39422 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39423 if (!SWIG_IsOK(ecode2)) {
39424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39425 }
39426 arg2 = static_cast< size_t >(val2);
39427 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39428 if (!SWIG_IsOK(res3)) {
39429 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39430 }
39431 {
39432 PyThreadState* __tstate = wxPyBeginAllowThreads();
39433 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39434 wxPyEndAllowThreads(__tstate);
39435 if (PyErr_Occurred()) SWIG_fail;
39436 }
39437 {
39438 resultobj = wxPyMake_wxObject(result, (bool)0);
39439 }
39440 return resultobj;
39441 fail:
39442 return NULL;
39443 }
39444
39445
39446 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39447 PyObject *resultobj = 0;
39448 wxMenu *arg1 = (wxMenu *) 0 ;
39449 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39450 wxMenuItem *result = 0 ;
39451 void *argp1 = 0 ;
39452 int res1 = 0 ;
39453 int res2 = 0 ;
39454 PyObject * obj0 = 0 ;
39455 PyObject * obj1 = 0 ;
39456 char * kwnames[] = {
39457 (char *) "self",(char *) "item", NULL
39458 };
39459
39460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39462 if (!SWIG_IsOK(res1)) {
39463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39464 }
39465 arg1 = reinterpret_cast< wxMenu * >(argp1);
39466 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39467 if (!SWIG_IsOK(res2)) {
39468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39469 }
39470 {
39471 PyThreadState* __tstate = wxPyBeginAllowThreads();
39472 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39473 wxPyEndAllowThreads(__tstate);
39474 if (PyErr_Occurred()) SWIG_fail;
39475 }
39476 {
39477 resultobj = wxPyMake_wxObject(result, (bool)0);
39478 }
39479 return resultobj;
39480 fail:
39481 return NULL;
39482 }
39483
39484
39485 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39486 PyObject *resultobj = 0;
39487 wxMenu *arg1 = (wxMenu *) 0 ;
39488 void *argp1 = 0 ;
39489 int res1 = 0 ;
39490 PyObject *swig_obj[1] ;
39491
39492 if (!args) SWIG_fail;
39493 swig_obj[0] = args;
39494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39495 if (!SWIG_IsOK(res1)) {
39496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39497 }
39498 arg1 = reinterpret_cast< wxMenu * >(argp1);
39499 {
39500 PyThreadState* __tstate = wxPyBeginAllowThreads();
39501 (arg1)->Break();
39502 wxPyEndAllowThreads(__tstate);
39503 if (PyErr_Occurred()) SWIG_fail;
39504 }
39505 resultobj = SWIG_Py_Void();
39506 return resultobj;
39507 fail:
39508 return NULL;
39509 }
39510
39511
39512 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39513 PyObject *resultobj = 0;
39514 wxMenu *arg1 = (wxMenu *) 0 ;
39515 size_t arg2 ;
39516 int arg3 ;
39517 wxString const &arg4_defvalue = wxPyEmptyString ;
39518 wxString *arg4 = (wxString *) &arg4_defvalue ;
39519 wxString const &arg5_defvalue = wxPyEmptyString ;
39520 wxString *arg5 = (wxString *) &arg5_defvalue ;
39521 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39522 wxMenuItem *result = 0 ;
39523 void *argp1 = 0 ;
39524 int res1 = 0 ;
39525 size_t val2 ;
39526 int ecode2 = 0 ;
39527 int val3 ;
39528 int ecode3 = 0 ;
39529 bool temp4 = false ;
39530 bool temp5 = false ;
39531 int val6 ;
39532 int ecode6 = 0 ;
39533 PyObject * obj0 = 0 ;
39534 PyObject * obj1 = 0 ;
39535 PyObject * obj2 = 0 ;
39536 PyObject * obj3 = 0 ;
39537 PyObject * obj4 = 0 ;
39538 PyObject * obj5 = 0 ;
39539 char * kwnames[] = {
39540 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39541 };
39542
39543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39545 if (!SWIG_IsOK(res1)) {
39546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39547 }
39548 arg1 = reinterpret_cast< wxMenu * >(argp1);
39549 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39550 if (!SWIG_IsOK(ecode2)) {
39551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39552 }
39553 arg2 = static_cast< size_t >(val2);
39554 ecode3 = SWIG_AsVal_int(obj2, &val3);
39555 if (!SWIG_IsOK(ecode3)) {
39556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39557 }
39558 arg3 = static_cast< int >(val3);
39559 if (obj3) {
39560 {
39561 arg4 = wxString_in_helper(obj3);
39562 if (arg4 == NULL) SWIG_fail;
39563 temp4 = true;
39564 }
39565 }
39566 if (obj4) {
39567 {
39568 arg5 = wxString_in_helper(obj4);
39569 if (arg5 == NULL) SWIG_fail;
39570 temp5 = true;
39571 }
39572 }
39573 if (obj5) {
39574 ecode6 = SWIG_AsVal_int(obj5, &val6);
39575 if (!SWIG_IsOK(ecode6)) {
39576 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39577 }
39578 arg6 = static_cast< wxItemKind >(val6);
39579 }
39580 {
39581 PyThreadState* __tstate = wxPyBeginAllowThreads();
39582 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39583 wxPyEndAllowThreads(__tstate);
39584 if (PyErr_Occurred()) SWIG_fail;
39585 }
39586 {
39587 resultobj = wxPyMake_wxObject(result, (bool)0);
39588 }
39589 {
39590 if (temp4)
39591 delete arg4;
39592 }
39593 {
39594 if (temp5)
39595 delete arg5;
39596 }
39597 return resultobj;
39598 fail:
39599 {
39600 if (temp4)
39601 delete arg4;
39602 }
39603 {
39604 if (temp5)
39605 delete arg5;
39606 }
39607 return NULL;
39608 }
39609
39610
39611 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39612 PyObject *resultobj = 0;
39613 wxMenu *arg1 = (wxMenu *) 0 ;
39614 size_t arg2 ;
39615 wxMenuItem *result = 0 ;
39616 void *argp1 = 0 ;
39617 int res1 = 0 ;
39618 size_t val2 ;
39619 int ecode2 = 0 ;
39620 PyObject * obj0 = 0 ;
39621 PyObject * obj1 = 0 ;
39622 char * kwnames[] = {
39623 (char *) "self",(char *) "pos", NULL
39624 };
39625
39626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39628 if (!SWIG_IsOK(res1)) {
39629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39630 }
39631 arg1 = reinterpret_cast< wxMenu * >(argp1);
39632 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39633 if (!SWIG_IsOK(ecode2)) {
39634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39635 }
39636 arg2 = static_cast< size_t >(val2);
39637 {
39638 PyThreadState* __tstate = wxPyBeginAllowThreads();
39639 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39640 wxPyEndAllowThreads(__tstate);
39641 if (PyErr_Occurred()) SWIG_fail;
39642 }
39643 {
39644 resultobj = wxPyMake_wxObject(result, (bool)0);
39645 }
39646 return resultobj;
39647 fail:
39648 return NULL;
39649 }
39650
39651
39652 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39653 PyObject *resultobj = 0;
39654 wxMenu *arg1 = (wxMenu *) 0 ;
39655 size_t arg2 ;
39656 int arg3 ;
39657 wxString *arg4 = 0 ;
39658 wxString const &arg5_defvalue = wxPyEmptyString ;
39659 wxString *arg5 = (wxString *) &arg5_defvalue ;
39660 wxMenuItem *result = 0 ;
39661 void *argp1 = 0 ;
39662 int res1 = 0 ;
39663 size_t val2 ;
39664 int ecode2 = 0 ;
39665 int val3 ;
39666 int ecode3 = 0 ;
39667 bool temp4 = false ;
39668 bool temp5 = false ;
39669 PyObject * obj0 = 0 ;
39670 PyObject * obj1 = 0 ;
39671 PyObject * obj2 = 0 ;
39672 PyObject * obj3 = 0 ;
39673 PyObject * obj4 = 0 ;
39674 char * kwnames[] = {
39675 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39676 };
39677
39678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39680 if (!SWIG_IsOK(res1)) {
39681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39682 }
39683 arg1 = reinterpret_cast< wxMenu * >(argp1);
39684 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39685 if (!SWIG_IsOK(ecode2)) {
39686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39687 }
39688 arg2 = static_cast< size_t >(val2);
39689 ecode3 = SWIG_AsVal_int(obj2, &val3);
39690 if (!SWIG_IsOK(ecode3)) {
39691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39692 }
39693 arg3 = static_cast< int >(val3);
39694 {
39695 arg4 = wxString_in_helper(obj3);
39696 if (arg4 == NULL) SWIG_fail;
39697 temp4 = true;
39698 }
39699 if (obj4) {
39700 {
39701 arg5 = wxString_in_helper(obj4);
39702 if (arg5 == NULL) SWIG_fail;
39703 temp5 = true;
39704 }
39705 }
39706 {
39707 PyThreadState* __tstate = wxPyBeginAllowThreads();
39708 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39709 wxPyEndAllowThreads(__tstate);
39710 if (PyErr_Occurred()) SWIG_fail;
39711 }
39712 {
39713 resultobj = wxPyMake_wxObject(result, (bool)0);
39714 }
39715 {
39716 if (temp4)
39717 delete arg4;
39718 }
39719 {
39720 if (temp5)
39721 delete arg5;
39722 }
39723 return resultobj;
39724 fail:
39725 {
39726 if (temp4)
39727 delete arg4;
39728 }
39729 {
39730 if (temp5)
39731 delete arg5;
39732 }
39733 return NULL;
39734 }
39735
39736
39737 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39738 PyObject *resultobj = 0;
39739 wxMenu *arg1 = (wxMenu *) 0 ;
39740 size_t arg2 ;
39741 int arg3 ;
39742 wxString *arg4 = 0 ;
39743 wxString const &arg5_defvalue = wxPyEmptyString ;
39744 wxString *arg5 = (wxString *) &arg5_defvalue ;
39745 wxMenuItem *result = 0 ;
39746 void *argp1 = 0 ;
39747 int res1 = 0 ;
39748 size_t val2 ;
39749 int ecode2 = 0 ;
39750 int val3 ;
39751 int ecode3 = 0 ;
39752 bool temp4 = false ;
39753 bool temp5 = false ;
39754 PyObject * obj0 = 0 ;
39755 PyObject * obj1 = 0 ;
39756 PyObject * obj2 = 0 ;
39757 PyObject * obj3 = 0 ;
39758 PyObject * obj4 = 0 ;
39759 char * kwnames[] = {
39760 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39761 };
39762
39763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39765 if (!SWIG_IsOK(res1)) {
39766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39767 }
39768 arg1 = reinterpret_cast< wxMenu * >(argp1);
39769 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39770 if (!SWIG_IsOK(ecode2)) {
39771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39772 }
39773 arg2 = static_cast< size_t >(val2);
39774 ecode3 = SWIG_AsVal_int(obj2, &val3);
39775 if (!SWIG_IsOK(ecode3)) {
39776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39777 }
39778 arg3 = static_cast< int >(val3);
39779 {
39780 arg4 = wxString_in_helper(obj3);
39781 if (arg4 == NULL) SWIG_fail;
39782 temp4 = true;
39783 }
39784 if (obj4) {
39785 {
39786 arg5 = wxString_in_helper(obj4);
39787 if (arg5 == NULL) SWIG_fail;
39788 temp5 = true;
39789 }
39790 }
39791 {
39792 PyThreadState* __tstate = wxPyBeginAllowThreads();
39793 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39794 wxPyEndAllowThreads(__tstate);
39795 if (PyErr_Occurred()) SWIG_fail;
39796 }
39797 {
39798 resultobj = wxPyMake_wxObject(result, (bool)0);
39799 }
39800 {
39801 if (temp4)
39802 delete arg4;
39803 }
39804 {
39805 if (temp5)
39806 delete arg5;
39807 }
39808 return resultobj;
39809 fail:
39810 {
39811 if (temp4)
39812 delete arg4;
39813 }
39814 {
39815 if (temp5)
39816 delete arg5;
39817 }
39818 return NULL;
39819 }
39820
39821
39822 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39823 PyObject *resultobj = 0;
39824 wxMenu *arg1 = (wxMenu *) 0 ;
39825 size_t arg2 ;
39826 int arg3 ;
39827 wxString *arg4 = 0 ;
39828 wxMenu *arg5 = (wxMenu *) 0 ;
39829 wxString const &arg6_defvalue = wxPyEmptyString ;
39830 wxString *arg6 = (wxString *) &arg6_defvalue ;
39831 wxMenuItem *result = 0 ;
39832 void *argp1 = 0 ;
39833 int res1 = 0 ;
39834 size_t val2 ;
39835 int ecode2 = 0 ;
39836 int val3 ;
39837 int ecode3 = 0 ;
39838 bool temp4 = false ;
39839 void *argp5 = 0 ;
39840 int res5 = 0 ;
39841 bool temp6 = false ;
39842 PyObject * obj0 = 0 ;
39843 PyObject * obj1 = 0 ;
39844 PyObject * obj2 = 0 ;
39845 PyObject * obj3 = 0 ;
39846 PyObject * obj4 = 0 ;
39847 PyObject * obj5 = 0 ;
39848 char * kwnames[] = {
39849 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39850 };
39851
39852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39854 if (!SWIG_IsOK(res1)) {
39855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39856 }
39857 arg1 = reinterpret_cast< wxMenu * >(argp1);
39858 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39859 if (!SWIG_IsOK(ecode2)) {
39860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39861 }
39862 arg2 = static_cast< size_t >(val2);
39863 ecode3 = SWIG_AsVal_int(obj2, &val3);
39864 if (!SWIG_IsOK(ecode3)) {
39865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39866 }
39867 arg3 = static_cast< int >(val3);
39868 {
39869 arg4 = wxString_in_helper(obj3);
39870 if (arg4 == NULL) SWIG_fail;
39871 temp4 = true;
39872 }
39873 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39874 if (!SWIG_IsOK(res5)) {
39875 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39876 }
39877 arg5 = reinterpret_cast< wxMenu * >(argp5);
39878 if (obj5) {
39879 {
39880 arg6 = wxString_in_helper(obj5);
39881 if (arg6 == NULL) SWIG_fail;
39882 temp6 = true;
39883 }
39884 }
39885 {
39886 PyThreadState* __tstate = wxPyBeginAllowThreads();
39887 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39888 wxPyEndAllowThreads(__tstate);
39889 if (PyErr_Occurred()) SWIG_fail;
39890 }
39891 {
39892 resultobj = wxPyMake_wxObject(result, (bool)0);
39893 }
39894 {
39895 if (temp4)
39896 delete arg4;
39897 }
39898 {
39899 if (temp6)
39900 delete arg6;
39901 }
39902 return resultobj;
39903 fail:
39904 {
39905 if (temp4)
39906 delete arg4;
39907 }
39908 {
39909 if (temp6)
39910 delete arg6;
39911 }
39912 return NULL;
39913 }
39914
39915
39916 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39917 PyObject *resultobj = 0;
39918 wxMenu *arg1 = (wxMenu *) 0 ;
39919 int arg2 ;
39920 wxString const &arg3_defvalue = wxPyEmptyString ;
39921 wxString *arg3 = (wxString *) &arg3_defvalue ;
39922 wxString const &arg4_defvalue = wxPyEmptyString ;
39923 wxString *arg4 = (wxString *) &arg4_defvalue ;
39924 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39925 wxMenuItem *result = 0 ;
39926 void *argp1 = 0 ;
39927 int res1 = 0 ;
39928 int val2 ;
39929 int ecode2 = 0 ;
39930 bool temp3 = false ;
39931 bool temp4 = false ;
39932 int val5 ;
39933 int ecode5 = 0 ;
39934 PyObject * obj0 = 0 ;
39935 PyObject * obj1 = 0 ;
39936 PyObject * obj2 = 0 ;
39937 PyObject * obj3 = 0 ;
39938 PyObject * obj4 = 0 ;
39939 char * kwnames[] = {
39940 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39941 };
39942
39943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39945 if (!SWIG_IsOK(res1)) {
39946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39947 }
39948 arg1 = reinterpret_cast< wxMenu * >(argp1);
39949 ecode2 = SWIG_AsVal_int(obj1, &val2);
39950 if (!SWIG_IsOK(ecode2)) {
39951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39952 }
39953 arg2 = static_cast< int >(val2);
39954 if (obj2) {
39955 {
39956 arg3 = wxString_in_helper(obj2);
39957 if (arg3 == NULL) SWIG_fail;
39958 temp3 = true;
39959 }
39960 }
39961 if (obj3) {
39962 {
39963 arg4 = wxString_in_helper(obj3);
39964 if (arg4 == NULL) SWIG_fail;
39965 temp4 = true;
39966 }
39967 }
39968 if (obj4) {
39969 ecode5 = SWIG_AsVal_int(obj4, &val5);
39970 if (!SWIG_IsOK(ecode5)) {
39971 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39972 }
39973 arg5 = static_cast< wxItemKind >(val5);
39974 }
39975 {
39976 PyThreadState* __tstate = wxPyBeginAllowThreads();
39977 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39978 wxPyEndAllowThreads(__tstate);
39979 if (PyErr_Occurred()) SWIG_fail;
39980 }
39981 {
39982 resultobj = wxPyMake_wxObject(result, (bool)0);
39983 }
39984 {
39985 if (temp3)
39986 delete arg3;
39987 }
39988 {
39989 if (temp4)
39990 delete arg4;
39991 }
39992 return resultobj;
39993 fail:
39994 {
39995 if (temp3)
39996 delete arg3;
39997 }
39998 {
39999 if (temp4)
40000 delete arg4;
40001 }
40002 return NULL;
40003 }
40004
40005
40006 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40007 PyObject *resultobj = 0;
40008 wxMenu *arg1 = (wxMenu *) 0 ;
40009 wxMenuItem *result = 0 ;
40010 void *argp1 = 0 ;
40011 int res1 = 0 ;
40012 PyObject *swig_obj[1] ;
40013
40014 if (!args) SWIG_fail;
40015 swig_obj[0] = args;
40016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40017 if (!SWIG_IsOK(res1)) {
40018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40019 }
40020 arg1 = reinterpret_cast< wxMenu * >(argp1);
40021 {
40022 PyThreadState* __tstate = wxPyBeginAllowThreads();
40023 result = (wxMenuItem *)(arg1)->PrependSeparator();
40024 wxPyEndAllowThreads(__tstate);
40025 if (PyErr_Occurred()) SWIG_fail;
40026 }
40027 {
40028 resultobj = wxPyMake_wxObject(result, (bool)0);
40029 }
40030 return resultobj;
40031 fail:
40032 return NULL;
40033 }
40034
40035
40036 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40037 PyObject *resultobj = 0;
40038 wxMenu *arg1 = (wxMenu *) 0 ;
40039 int arg2 ;
40040 wxString *arg3 = 0 ;
40041 wxString const &arg4_defvalue = wxPyEmptyString ;
40042 wxString *arg4 = (wxString *) &arg4_defvalue ;
40043 wxMenuItem *result = 0 ;
40044 void *argp1 = 0 ;
40045 int res1 = 0 ;
40046 int val2 ;
40047 int ecode2 = 0 ;
40048 bool temp3 = false ;
40049 bool temp4 = false ;
40050 PyObject * obj0 = 0 ;
40051 PyObject * obj1 = 0 ;
40052 PyObject * obj2 = 0 ;
40053 PyObject * obj3 = 0 ;
40054 char * kwnames[] = {
40055 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40056 };
40057
40058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40060 if (!SWIG_IsOK(res1)) {
40061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40062 }
40063 arg1 = reinterpret_cast< wxMenu * >(argp1);
40064 ecode2 = SWIG_AsVal_int(obj1, &val2);
40065 if (!SWIG_IsOK(ecode2)) {
40066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40067 }
40068 arg2 = static_cast< int >(val2);
40069 {
40070 arg3 = wxString_in_helper(obj2);
40071 if (arg3 == NULL) SWIG_fail;
40072 temp3 = true;
40073 }
40074 if (obj3) {
40075 {
40076 arg4 = wxString_in_helper(obj3);
40077 if (arg4 == NULL) SWIG_fail;
40078 temp4 = true;
40079 }
40080 }
40081 {
40082 PyThreadState* __tstate = wxPyBeginAllowThreads();
40083 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40084 wxPyEndAllowThreads(__tstate);
40085 if (PyErr_Occurred()) SWIG_fail;
40086 }
40087 {
40088 resultobj = wxPyMake_wxObject(result, (bool)0);
40089 }
40090 {
40091 if (temp3)
40092 delete arg3;
40093 }
40094 {
40095 if (temp4)
40096 delete arg4;
40097 }
40098 return resultobj;
40099 fail:
40100 {
40101 if (temp3)
40102 delete arg3;
40103 }
40104 {
40105 if (temp4)
40106 delete arg4;
40107 }
40108 return NULL;
40109 }
40110
40111
40112 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(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_PrependRadioItem",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_PrependRadioItem" "', 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_PrependRadioItem" "', 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)->PrependRadioItem(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_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40189 PyObject *resultobj = 0;
40190 wxMenu *arg1 = (wxMenu *) 0 ;
40191 int arg2 ;
40192 wxString *arg3 = 0 ;
40193 wxMenu *arg4 = (wxMenu *) 0 ;
40194 wxString const &arg5_defvalue = wxPyEmptyString ;
40195 wxString *arg5 = (wxString *) &arg5_defvalue ;
40196 wxMenuItem *result = 0 ;
40197 void *argp1 = 0 ;
40198 int res1 = 0 ;
40199 int val2 ;
40200 int ecode2 = 0 ;
40201 bool temp3 = false ;
40202 void *argp4 = 0 ;
40203 int res4 = 0 ;
40204 bool temp5 = false ;
40205 PyObject * obj0 = 0 ;
40206 PyObject * obj1 = 0 ;
40207 PyObject * obj2 = 0 ;
40208 PyObject * obj3 = 0 ;
40209 PyObject * obj4 = 0 ;
40210 char * kwnames[] = {
40211 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40212 };
40213
40214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40216 if (!SWIG_IsOK(res1)) {
40217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40218 }
40219 arg1 = reinterpret_cast< wxMenu * >(argp1);
40220 ecode2 = SWIG_AsVal_int(obj1, &val2);
40221 if (!SWIG_IsOK(ecode2)) {
40222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40223 }
40224 arg2 = static_cast< int >(val2);
40225 {
40226 arg3 = wxString_in_helper(obj2);
40227 if (arg3 == NULL) SWIG_fail;
40228 temp3 = true;
40229 }
40230 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40231 if (!SWIG_IsOK(res4)) {
40232 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40233 }
40234 arg4 = reinterpret_cast< wxMenu * >(argp4);
40235 if (obj4) {
40236 {
40237 arg5 = wxString_in_helper(obj4);
40238 if (arg5 == NULL) SWIG_fail;
40239 temp5 = true;
40240 }
40241 }
40242 {
40243 PyThreadState* __tstate = wxPyBeginAllowThreads();
40244 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40245 wxPyEndAllowThreads(__tstate);
40246 if (PyErr_Occurred()) SWIG_fail;
40247 }
40248 {
40249 resultobj = wxPyMake_wxObject(result, (bool)0);
40250 }
40251 {
40252 if (temp3)
40253 delete arg3;
40254 }
40255 {
40256 if (temp5)
40257 delete arg5;
40258 }
40259 return resultobj;
40260 fail:
40261 {
40262 if (temp3)
40263 delete arg3;
40264 }
40265 {
40266 if (temp5)
40267 delete arg5;
40268 }
40269 return NULL;
40270 }
40271
40272
40273 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40274 PyObject *resultobj = 0;
40275 wxMenu *arg1 = (wxMenu *) 0 ;
40276 int arg2 ;
40277 wxMenuItem *result = 0 ;
40278 void *argp1 = 0 ;
40279 int res1 = 0 ;
40280 int val2 ;
40281 int ecode2 = 0 ;
40282 PyObject * obj0 = 0 ;
40283 PyObject * obj1 = 0 ;
40284 char * kwnames[] = {
40285 (char *) "self",(char *) "id", NULL
40286 };
40287
40288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40290 if (!SWIG_IsOK(res1)) {
40291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40292 }
40293 arg1 = reinterpret_cast< wxMenu * >(argp1);
40294 ecode2 = SWIG_AsVal_int(obj1, &val2);
40295 if (!SWIG_IsOK(ecode2)) {
40296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40297 }
40298 arg2 = static_cast< int >(val2);
40299 {
40300 PyThreadState* __tstate = wxPyBeginAllowThreads();
40301 result = (wxMenuItem *)(arg1)->Remove(arg2);
40302 wxPyEndAllowThreads(__tstate);
40303 if (PyErr_Occurred()) SWIG_fail;
40304 }
40305 {
40306 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40307 }
40308 return resultobj;
40309 fail:
40310 return NULL;
40311 }
40312
40313
40314 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40315 PyObject *resultobj = 0;
40316 wxMenu *arg1 = (wxMenu *) 0 ;
40317 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40318 wxMenuItem *result = 0 ;
40319 void *argp1 = 0 ;
40320 int res1 = 0 ;
40321 void *argp2 = 0 ;
40322 int res2 = 0 ;
40323 PyObject * obj0 = 0 ;
40324 PyObject * obj1 = 0 ;
40325 char * kwnames[] = {
40326 (char *) "self",(char *) "item", NULL
40327 };
40328
40329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40331 if (!SWIG_IsOK(res1)) {
40332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40333 }
40334 arg1 = reinterpret_cast< wxMenu * >(argp1);
40335 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40336 if (!SWIG_IsOK(res2)) {
40337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40338 }
40339 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40340 {
40341 PyThreadState* __tstate = wxPyBeginAllowThreads();
40342 result = (wxMenuItem *)(arg1)->Remove(arg2);
40343 wxPyEndAllowThreads(__tstate);
40344 if (PyErr_Occurred()) SWIG_fail;
40345 }
40346 {
40347 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40348 }
40349 return resultobj;
40350 fail:
40351 return NULL;
40352 }
40353
40354
40355 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40356 PyObject *resultobj = 0;
40357 wxMenu *arg1 = (wxMenu *) 0 ;
40358 int arg2 ;
40359 bool result;
40360 void *argp1 = 0 ;
40361 int res1 = 0 ;
40362 int val2 ;
40363 int ecode2 = 0 ;
40364 PyObject * obj0 = 0 ;
40365 PyObject * obj1 = 0 ;
40366 char * kwnames[] = {
40367 (char *) "self",(char *) "id", NULL
40368 };
40369
40370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40372 if (!SWIG_IsOK(res1)) {
40373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40374 }
40375 arg1 = reinterpret_cast< wxMenu * >(argp1);
40376 ecode2 = SWIG_AsVal_int(obj1, &val2);
40377 if (!SWIG_IsOK(ecode2)) {
40378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40379 }
40380 arg2 = static_cast< int >(val2);
40381 {
40382 PyThreadState* __tstate = wxPyBeginAllowThreads();
40383 result = (bool)(arg1)->Delete(arg2);
40384 wxPyEndAllowThreads(__tstate);
40385 if (PyErr_Occurred()) SWIG_fail;
40386 }
40387 {
40388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40389 }
40390 return resultobj;
40391 fail:
40392 return NULL;
40393 }
40394
40395
40396 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40397 PyObject *resultobj = 0;
40398 wxMenu *arg1 = (wxMenu *) 0 ;
40399 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40400 bool result;
40401 void *argp1 = 0 ;
40402 int res1 = 0 ;
40403 void *argp2 = 0 ;
40404 int res2 = 0 ;
40405 PyObject * obj0 = 0 ;
40406 PyObject * obj1 = 0 ;
40407 char * kwnames[] = {
40408 (char *) "self",(char *) "item", NULL
40409 };
40410
40411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40413 if (!SWIG_IsOK(res1)) {
40414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40415 }
40416 arg1 = reinterpret_cast< wxMenu * >(argp1);
40417 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40418 if (!SWIG_IsOK(res2)) {
40419 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40420 }
40421 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40422 {
40423 PyThreadState* __tstate = wxPyBeginAllowThreads();
40424 result = (bool)(arg1)->Delete(arg2);
40425 wxPyEndAllowThreads(__tstate);
40426 if (PyErr_Occurred()) SWIG_fail;
40427 }
40428 {
40429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40430 }
40431 return resultobj;
40432 fail:
40433 return NULL;
40434 }
40435
40436
40437 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40438 PyObject *resultobj = 0;
40439 wxMenu *arg1 = (wxMenu *) 0 ;
40440 void *argp1 = 0 ;
40441 int res1 = 0 ;
40442 PyObject *swig_obj[1] ;
40443
40444 if (!args) SWIG_fail;
40445 swig_obj[0] = args;
40446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40447 if (!SWIG_IsOK(res1)) {
40448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40449 }
40450 arg1 = reinterpret_cast< wxMenu * >(argp1);
40451 {
40452 PyThreadState* __tstate = wxPyBeginAllowThreads();
40453 wxMenu_Destroy(arg1);
40454 wxPyEndAllowThreads(__tstate);
40455 if (PyErr_Occurred()) SWIG_fail;
40456 }
40457 resultobj = SWIG_Py_Void();
40458 return resultobj;
40459 fail:
40460 return NULL;
40461 }
40462
40463
40464 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40465 PyObject *resultobj = 0;
40466 wxMenu *arg1 = (wxMenu *) 0 ;
40467 int arg2 ;
40468 bool result;
40469 void *argp1 = 0 ;
40470 int res1 = 0 ;
40471 int val2 ;
40472 int ecode2 = 0 ;
40473 PyObject * obj0 = 0 ;
40474 PyObject * obj1 = 0 ;
40475 char * kwnames[] = {
40476 (char *) "self",(char *) "id", NULL
40477 };
40478
40479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40481 if (!SWIG_IsOK(res1)) {
40482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40483 }
40484 arg1 = reinterpret_cast< wxMenu * >(argp1);
40485 ecode2 = SWIG_AsVal_int(obj1, &val2);
40486 if (!SWIG_IsOK(ecode2)) {
40487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40488 }
40489 arg2 = static_cast< int >(val2);
40490 {
40491 PyThreadState* __tstate = wxPyBeginAllowThreads();
40492 result = (bool)(arg1)->Destroy(arg2);
40493 wxPyEndAllowThreads(__tstate);
40494 if (PyErr_Occurred()) SWIG_fail;
40495 }
40496 {
40497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40498 }
40499 return resultobj;
40500 fail:
40501 return NULL;
40502 }
40503
40504
40505 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40506 PyObject *resultobj = 0;
40507 wxMenu *arg1 = (wxMenu *) 0 ;
40508 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40509 bool result;
40510 void *argp1 = 0 ;
40511 int res1 = 0 ;
40512 void *argp2 = 0 ;
40513 int res2 = 0 ;
40514 PyObject * obj0 = 0 ;
40515 PyObject * obj1 = 0 ;
40516 char * kwnames[] = {
40517 (char *) "self",(char *) "item", NULL
40518 };
40519
40520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40522 if (!SWIG_IsOK(res1)) {
40523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40524 }
40525 arg1 = reinterpret_cast< wxMenu * >(argp1);
40526 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40527 if (!SWIG_IsOK(res2)) {
40528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40529 }
40530 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40531 {
40532 PyThreadState* __tstate = wxPyBeginAllowThreads();
40533 result = (bool)(arg1)->Destroy(arg2);
40534 wxPyEndAllowThreads(__tstate);
40535 if (PyErr_Occurred()) SWIG_fail;
40536 }
40537 {
40538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40539 }
40540 return resultobj;
40541 fail:
40542 return NULL;
40543 }
40544
40545
40546 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40547 PyObject *resultobj = 0;
40548 wxMenu *arg1 = (wxMenu *) 0 ;
40549 size_t result;
40550 void *argp1 = 0 ;
40551 int res1 = 0 ;
40552 PyObject *swig_obj[1] ;
40553
40554 if (!args) SWIG_fail;
40555 swig_obj[0] = args;
40556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40557 if (!SWIG_IsOK(res1)) {
40558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40559 }
40560 arg1 = reinterpret_cast< wxMenu * >(argp1);
40561 {
40562 PyThreadState* __tstate = wxPyBeginAllowThreads();
40563 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40564 wxPyEndAllowThreads(__tstate);
40565 if (PyErr_Occurred()) SWIG_fail;
40566 }
40567 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40568 return resultobj;
40569 fail:
40570 return NULL;
40571 }
40572
40573
40574 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40575 PyObject *resultobj = 0;
40576 wxMenu *arg1 = (wxMenu *) 0 ;
40577 PyObject *result = 0 ;
40578 void *argp1 = 0 ;
40579 int res1 = 0 ;
40580 PyObject *swig_obj[1] ;
40581
40582 if (!args) SWIG_fail;
40583 swig_obj[0] = args;
40584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40585 if (!SWIG_IsOK(res1)) {
40586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40587 }
40588 arg1 = reinterpret_cast< wxMenu * >(argp1);
40589 {
40590 PyThreadState* __tstate = wxPyBeginAllowThreads();
40591 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40592 wxPyEndAllowThreads(__tstate);
40593 if (PyErr_Occurred()) SWIG_fail;
40594 }
40595 resultobj = result;
40596 return resultobj;
40597 fail:
40598 return NULL;
40599 }
40600
40601
40602 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40603 PyObject *resultobj = 0;
40604 wxMenu *arg1 = (wxMenu *) 0 ;
40605 wxString *arg2 = 0 ;
40606 int result;
40607 void *argp1 = 0 ;
40608 int res1 = 0 ;
40609 bool temp2 = false ;
40610 PyObject * obj0 = 0 ;
40611 PyObject * obj1 = 0 ;
40612 char * kwnames[] = {
40613 (char *) "self",(char *) "item", NULL
40614 };
40615
40616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40618 if (!SWIG_IsOK(res1)) {
40619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40620 }
40621 arg1 = reinterpret_cast< wxMenu * >(argp1);
40622 {
40623 arg2 = wxString_in_helper(obj1);
40624 if (arg2 == NULL) SWIG_fail;
40625 temp2 = true;
40626 }
40627 {
40628 PyThreadState* __tstate = wxPyBeginAllowThreads();
40629 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40630 wxPyEndAllowThreads(__tstate);
40631 if (PyErr_Occurred()) SWIG_fail;
40632 }
40633 resultobj = SWIG_From_int(static_cast< int >(result));
40634 {
40635 if (temp2)
40636 delete arg2;
40637 }
40638 return resultobj;
40639 fail:
40640 {
40641 if (temp2)
40642 delete arg2;
40643 }
40644 return NULL;
40645 }
40646
40647
40648 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40649 PyObject *resultobj = 0;
40650 wxMenu *arg1 = (wxMenu *) 0 ;
40651 int arg2 ;
40652 wxMenuItem *result = 0 ;
40653 void *argp1 = 0 ;
40654 int res1 = 0 ;
40655 int val2 ;
40656 int ecode2 = 0 ;
40657 PyObject * obj0 = 0 ;
40658 PyObject * obj1 = 0 ;
40659 char * kwnames[] = {
40660 (char *) "self",(char *) "id", NULL
40661 };
40662
40663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40665 if (!SWIG_IsOK(res1)) {
40666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40667 }
40668 arg1 = reinterpret_cast< wxMenu * >(argp1);
40669 ecode2 = SWIG_AsVal_int(obj1, &val2);
40670 if (!SWIG_IsOK(ecode2)) {
40671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40672 }
40673 arg2 = static_cast< int >(val2);
40674 {
40675 PyThreadState* __tstate = wxPyBeginAllowThreads();
40676 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40677 wxPyEndAllowThreads(__tstate);
40678 if (PyErr_Occurred()) SWIG_fail;
40679 }
40680 {
40681 resultobj = wxPyMake_wxObject(result, (bool)0);
40682 }
40683 return resultobj;
40684 fail:
40685 return NULL;
40686 }
40687
40688
40689 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40690 PyObject *resultobj = 0;
40691 wxMenu *arg1 = (wxMenu *) 0 ;
40692 size_t arg2 ;
40693 wxMenuItem *result = 0 ;
40694 void *argp1 = 0 ;
40695 int res1 = 0 ;
40696 size_t val2 ;
40697 int ecode2 = 0 ;
40698 PyObject * obj0 = 0 ;
40699 PyObject * obj1 = 0 ;
40700 char * kwnames[] = {
40701 (char *) "self",(char *) "position", NULL
40702 };
40703
40704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40706 if (!SWIG_IsOK(res1)) {
40707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40708 }
40709 arg1 = reinterpret_cast< wxMenu * >(argp1);
40710 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40711 if (!SWIG_IsOK(ecode2)) {
40712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40713 }
40714 arg2 = static_cast< size_t >(val2);
40715 {
40716 PyThreadState* __tstate = wxPyBeginAllowThreads();
40717 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40718 wxPyEndAllowThreads(__tstate);
40719 if (PyErr_Occurred()) SWIG_fail;
40720 }
40721 {
40722 resultobj = wxPyMake_wxObject(result, (bool)0);
40723 }
40724 return resultobj;
40725 fail:
40726 return NULL;
40727 }
40728
40729
40730 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40731 PyObject *resultobj = 0;
40732 wxMenu *arg1 = (wxMenu *) 0 ;
40733 int arg2 ;
40734 bool arg3 ;
40735 void *argp1 = 0 ;
40736 int res1 = 0 ;
40737 int val2 ;
40738 int ecode2 = 0 ;
40739 bool val3 ;
40740 int ecode3 = 0 ;
40741 PyObject * obj0 = 0 ;
40742 PyObject * obj1 = 0 ;
40743 PyObject * obj2 = 0 ;
40744 char * kwnames[] = {
40745 (char *) "self",(char *) "id",(char *) "enable", NULL
40746 };
40747
40748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40750 if (!SWIG_IsOK(res1)) {
40751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40752 }
40753 arg1 = reinterpret_cast< wxMenu * >(argp1);
40754 ecode2 = SWIG_AsVal_int(obj1, &val2);
40755 if (!SWIG_IsOK(ecode2)) {
40756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40757 }
40758 arg2 = static_cast< int >(val2);
40759 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40760 if (!SWIG_IsOK(ecode3)) {
40761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40762 }
40763 arg3 = static_cast< bool >(val3);
40764 {
40765 PyThreadState* __tstate = wxPyBeginAllowThreads();
40766 (arg1)->Enable(arg2,arg3);
40767 wxPyEndAllowThreads(__tstate);
40768 if (PyErr_Occurred()) SWIG_fail;
40769 }
40770 resultobj = SWIG_Py_Void();
40771 return resultobj;
40772 fail:
40773 return NULL;
40774 }
40775
40776
40777 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40778 PyObject *resultobj = 0;
40779 wxMenu *arg1 = (wxMenu *) 0 ;
40780 int arg2 ;
40781 bool result;
40782 void *argp1 = 0 ;
40783 int res1 = 0 ;
40784 int val2 ;
40785 int ecode2 = 0 ;
40786 PyObject * obj0 = 0 ;
40787 PyObject * obj1 = 0 ;
40788 char * kwnames[] = {
40789 (char *) "self",(char *) "id", NULL
40790 };
40791
40792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40794 if (!SWIG_IsOK(res1)) {
40795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40796 }
40797 arg1 = reinterpret_cast< wxMenu * >(argp1);
40798 ecode2 = SWIG_AsVal_int(obj1, &val2);
40799 if (!SWIG_IsOK(ecode2)) {
40800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40801 }
40802 arg2 = static_cast< int >(val2);
40803 {
40804 PyThreadState* __tstate = wxPyBeginAllowThreads();
40805 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40806 wxPyEndAllowThreads(__tstate);
40807 if (PyErr_Occurred()) SWIG_fail;
40808 }
40809 {
40810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40811 }
40812 return resultobj;
40813 fail:
40814 return NULL;
40815 }
40816
40817
40818 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40819 PyObject *resultobj = 0;
40820 wxMenu *arg1 = (wxMenu *) 0 ;
40821 int arg2 ;
40822 bool arg3 ;
40823 void *argp1 = 0 ;
40824 int res1 = 0 ;
40825 int val2 ;
40826 int ecode2 = 0 ;
40827 bool val3 ;
40828 int ecode3 = 0 ;
40829 PyObject * obj0 = 0 ;
40830 PyObject * obj1 = 0 ;
40831 PyObject * obj2 = 0 ;
40832 char * kwnames[] = {
40833 (char *) "self",(char *) "id",(char *) "check", NULL
40834 };
40835
40836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40838 if (!SWIG_IsOK(res1)) {
40839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40840 }
40841 arg1 = reinterpret_cast< wxMenu * >(argp1);
40842 ecode2 = SWIG_AsVal_int(obj1, &val2);
40843 if (!SWIG_IsOK(ecode2)) {
40844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40845 }
40846 arg2 = static_cast< int >(val2);
40847 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40848 if (!SWIG_IsOK(ecode3)) {
40849 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40850 }
40851 arg3 = static_cast< bool >(val3);
40852 {
40853 PyThreadState* __tstate = wxPyBeginAllowThreads();
40854 (arg1)->Check(arg2,arg3);
40855 wxPyEndAllowThreads(__tstate);
40856 if (PyErr_Occurred()) SWIG_fail;
40857 }
40858 resultobj = SWIG_Py_Void();
40859 return resultobj;
40860 fail:
40861 return NULL;
40862 }
40863
40864
40865 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40866 PyObject *resultobj = 0;
40867 wxMenu *arg1 = (wxMenu *) 0 ;
40868 int arg2 ;
40869 bool result;
40870 void *argp1 = 0 ;
40871 int res1 = 0 ;
40872 int val2 ;
40873 int ecode2 = 0 ;
40874 PyObject * obj0 = 0 ;
40875 PyObject * obj1 = 0 ;
40876 char * kwnames[] = {
40877 (char *) "self",(char *) "id", NULL
40878 };
40879
40880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40882 if (!SWIG_IsOK(res1)) {
40883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40884 }
40885 arg1 = reinterpret_cast< wxMenu * >(argp1);
40886 ecode2 = SWIG_AsVal_int(obj1, &val2);
40887 if (!SWIG_IsOK(ecode2)) {
40888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40889 }
40890 arg2 = static_cast< int >(val2);
40891 {
40892 PyThreadState* __tstate = wxPyBeginAllowThreads();
40893 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40894 wxPyEndAllowThreads(__tstate);
40895 if (PyErr_Occurred()) SWIG_fail;
40896 }
40897 {
40898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40899 }
40900 return resultobj;
40901 fail:
40902 return NULL;
40903 }
40904
40905
40906 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40907 PyObject *resultobj = 0;
40908 wxMenu *arg1 = (wxMenu *) 0 ;
40909 int arg2 ;
40910 wxString *arg3 = 0 ;
40911 void *argp1 = 0 ;
40912 int res1 = 0 ;
40913 int val2 ;
40914 int ecode2 = 0 ;
40915 bool temp3 = false ;
40916 PyObject * obj0 = 0 ;
40917 PyObject * obj1 = 0 ;
40918 PyObject * obj2 = 0 ;
40919 char * kwnames[] = {
40920 (char *) "self",(char *) "id",(char *) "label", NULL
40921 };
40922
40923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40925 if (!SWIG_IsOK(res1)) {
40926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40927 }
40928 arg1 = reinterpret_cast< wxMenu * >(argp1);
40929 ecode2 = SWIG_AsVal_int(obj1, &val2);
40930 if (!SWIG_IsOK(ecode2)) {
40931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40932 }
40933 arg2 = static_cast< int >(val2);
40934 {
40935 arg3 = wxString_in_helper(obj2);
40936 if (arg3 == NULL) SWIG_fail;
40937 temp3 = true;
40938 }
40939 {
40940 PyThreadState* __tstate = wxPyBeginAllowThreads();
40941 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40942 wxPyEndAllowThreads(__tstate);
40943 if (PyErr_Occurred()) SWIG_fail;
40944 }
40945 resultobj = SWIG_Py_Void();
40946 {
40947 if (temp3)
40948 delete arg3;
40949 }
40950 return resultobj;
40951 fail:
40952 {
40953 if (temp3)
40954 delete arg3;
40955 }
40956 return NULL;
40957 }
40958
40959
40960 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40961 PyObject *resultobj = 0;
40962 wxMenu *arg1 = (wxMenu *) 0 ;
40963 int arg2 ;
40964 wxString result;
40965 void *argp1 = 0 ;
40966 int res1 = 0 ;
40967 int val2 ;
40968 int ecode2 = 0 ;
40969 PyObject * obj0 = 0 ;
40970 PyObject * obj1 = 0 ;
40971 char * kwnames[] = {
40972 (char *) "self",(char *) "id", NULL
40973 };
40974
40975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40977 if (!SWIG_IsOK(res1)) {
40978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40979 }
40980 arg1 = reinterpret_cast< wxMenu * >(argp1);
40981 ecode2 = SWIG_AsVal_int(obj1, &val2);
40982 if (!SWIG_IsOK(ecode2)) {
40983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40984 }
40985 arg2 = static_cast< int >(val2);
40986 {
40987 PyThreadState* __tstate = wxPyBeginAllowThreads();
40988 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40989 wxPyEndAllowThreads(__tstate);
40990 if (PyErr_Occurred()) SWIG_fail;
40991 }
40992 {
40993 #if wxUSE_UNICODE
40994 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40995 #else
40996 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40997 #endif
40998 }
40999 return resultobj;
41000 fail:
41001 return NULL;
41002 }
41003
41004
41005 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41006 PyObject *resultobj = 0;
41007 wxMenu *arg1 = (wxMenu *) 0 ;
41008 int arg2 ;
41009 wxString *arg3 = 0 ;
41010 void *argp1 = 0 ;
41011 int res1 = 0 ;
41012 int val2 ;
41013 int ecode2 = 0 ;
41014 bool temp3 = false ;
41015 PyObject * obj0 = 0 ;
41016 PyObject * obj1 = 0 ;
41017 PyObject * obj2 = 0 ;
41018 char * kwnames[] = {
41019 (char *) "self",(char *) "id",(char *) "helpString", NULL
41020 };
41021
41022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41024 if (!SWIG_IsOK(res1)) {
41025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41026 }
41027 arg1 = reinterpret_cast< wxMenu * >(argp1);
41028 ecode2 = SWIG_AsVal_int(obj1, &val2);
41029 if (!SWIG_IsOK(ecode2)) {
41030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41031 }
41032 arg2 = static_cast< int >(val2);
41033 {
41034 arg3 = wxString_in_helper(obj2);
41035 if (arg3 == NULL) SWIG_fail;
41036 temp3 = true;
41037 }
41038 {
41039 PyThreadState* __tstate = wxPyBeginAllowThreads();
41040 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41041 wxPyEndAllowThreads(__tstate);
41042 if (PyErr_Occurred()) SWIG_fail;
41043 }
41044 resultobj = SWIG_Py_Void();
41045 {
41046 if (temp3)
41047 delete arg3;
41048 }
41049 return resultobj;
41050 fail:
41051 {
41052 if (temp3)
41053 delete arg3;
41054 }
41055 return NULL;
41056 }
41057
41058
41059 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41060 PyObject *resultobj = 0;
41061 wxMenu *arg1 = (wxMenu *) 0 ;
41062 int arg2 ;
41063 wxString result;
41064 void *argp1 = 0 ;
41065 int res1 = 0 ;
41066 int val2 ;
41067 int ecode2 = 0 ;
41068 PyObject * obj0 = 0 ;
41069 PyObject * obj1 = 0 ;
41070 char * kwnames[] = {
41071 (char *) "self",(char *) "id", NULL
41072 };
41073
41074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41076 if (!SWIG_IsOK(res1)) {
41077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41078 }
41079 arg1 = reinterpret_cast< wxMenu * >(argp1);
41080 ecode2 = SWIG_AsVal_int(obj1, &val2);
41081 if (!SWIG_IsOK(ecode2)) {
41082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41083 }
41084 arg2 = static_cast< int >(val2);
41085 {
41086 PyThreadState* __tstate = wxPyBeginAllowThreads();
41087 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41088 wxPyEndAllowThreads(__tstate);
41089 if (PyErr_Occurred()) SWIG_fail;
41090 }
41091 {
41092 #if wxUSE_UNICODE
41093 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41094 #else
41095 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41096 #endif
41097 }
41098 return resultobj;
41099 fail:
41100 return NULL;
41101 }
41102
41103
41104 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41105 PyObject *resultobj = 0;
41106 wxMenu *arg1 = (wxMenu *) 0 ;
41107 wxString *arg2 = 0 ;
41108 void *argp1 = 0 ;
41109 int res1 = 0 ;
41110 bool temp2 = false ;
41111 PyObject * obj0 = 0 ;
41112 PyObject * obj1 = 0 ;
41113 char * kwnames[] = {
41114 (char *) "self",(char *) "title", NULL
41115 };
41116
41117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41119 if (!SWIG_IsOK(res1)) {
41120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41121 }
41122 arg1 = reinterpret_cast< wxMenu * >(argp1);
41123 {
41124 arg2 = wxString_in_helper(obj1);
41125 if (arg2 == NULL) SWIG_fail;
41126 temp2 = true;
41127 }
41128 {
41129 PyThreadState* __tstate = wxPyBeginAllowThreads();
41130 (arg1)->SetTitle((wxString const &)*arg2);
41131 wxPyEndAllowThreads(__tstate);
41132 if (PyErr_Occurred()) SWIG_fail;
41133 }
41134 resultobj = SWIG_Py_Void();
41135 {
41136 if (temp2)
41137 delete arg2;
41138 }
41139 return resultobj;
41140 fail:
41141 {
41142 if (temp2)
41143 delete arg2;
41144 }
41145 return NULL;
41146 }
41147
41148
41149 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41150 PyObject *resultobj = 0;
41151 wxMenu *arg1 = (wxMenu *) 0 ;
41152 wxString result;
41153 void *argp1 = 0 ;
41154 int res1 = 0 ;
41155 PyObject *swig_obj[1] ;
41156
41157 if (!args) SWIG_fail;
41158 swig_obj[0] = args;
41159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41160 if (!SWIG_IsOK(res1)) {
41161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41162 }
41163 arg1 = reinterpret_cast< wxMenu * >(argp1);
41164 {
41165 PyThreadState* __tstate = wxPyBeginAllowThreads();
41166 result = ((wxMenu const *)arg1)->GetTitle();
41167 wxPyEndAllowThreads(__tstate);
41168 if (PyErr_Occurred()) SWIG_fail;
41169 }
41170 {
41171 #if wxUSE_UNICODE
41172 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41173 #else
41174 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41175 #endif
41176 }
41177 return resultobj;
41178 fail:
41179 return NULL;
41180 }
41181
41182
41183 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41184 PyObject *resultobj = 0;
41185 wxMenu *arg1 = (wxMenu *) 0 ;
41186 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41187 void *argp1 = 0 ;
41188 int res1 = 0 ;
41189 void *argp2 = 0 ;
41190 int res2 = 0 ;
41191 PyObject * obj0 = 0 ;
41192 PyObject * obj1 = 0 ;
41193 char * kwnames[] = {
41194 (char *) "self",(char *) "handler", NULL
41195 };
41196
41197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41199 if (!SWIG_IsOK(res1)) {
41200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41201 }
41202 arg1 = reinterpret_cast< wxMenu * >(argp1);
41203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41204 if (!SWIG_IsOK(res2)) {
41205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41206 }
41207 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41208 {
41209 PyThreadState* __tstate = wxPyBeginAllowThreads();
41210 (arg1)->SetEventHandler(arg2);
41211 wxPyEndAllowThreads(__tstate);
41212 if (PyErr_Occurred()) SWIG_fail;
41213 }
41214 resultobj = SWIG_Py_Void();
41215 return resultobj;
41216 fail:
41217 return NULL;
41218 }
41219
41220
41221 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41222 PyObject *resultobj = 0;
41223 wxMenu *arg1 = (wxMenu *) 0 ;
41224 wxEvtHandler *result = 0 ;
41225 void *argp1 = 0 ;
41226 int res1 = 0 ;
41227 PyObject *swig_obj[1] ;
41228
41229 if (!args) SWIG_fail;
41230 swig_obj[0] = args;
41231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41232 if (!SWIG_IsOK(res1)) {
41233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41234 }
41235 arg1 = reinterpret_cast< wxMenu * >(argp1);
41236 {
41237 PyThreadState* __tstate = wxPyBeginAllowThreads();
41238 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41239 wxPyEndAllowThreads(__tstate);
41240 if (PyErr_Occurred()) SWIG_fail;
41241 }
41242 {
41243 resultobj = wxPyMake_wxObject(result, 0);
41244 }
41245 return resultobj;
41246 fail:
41247 return NULL;
41248 }
41249
41250
41251 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41252 PyObject *resultobj = 0;
41253 wxMenu *arg1 = (wxMenu *) 0 ;
41254 wxWindow *arg2 = (wxWindow *) 0 ;
41255 void *argp1 = 0 ;
41256 int res1 = 0 ;
41257 void *argp2 = 0 ;
41258 int res2 = 0 ;
41259 PyObject * obj0 = 0 ;
41260 PyObject * obj1 = 0 ;
41261 char * kwnames[] = {
41262 (char *) "self",(char *) "win", NULL
41263 };
41264
41265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41267 if (!SWIG_IsOK(res1)) {
41268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41269 }
41270 arg1 = reinterpret_cast< wxMenu * >(argp1);
41271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41272 if (!SWIG_IsOK(res2)) {
41273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41274 }
41275 arg2 = reinterpret_cast< wxWindow * >(argp2);
41276 {
41277 PyThreadState* __tstate = wxPyBeginAllowThreads();
41278 (arg1)->SetInvokingWindow(arg2);
41279 wxPyEndAllowThreads(__tstate);
41280 if (PyErr_Occurred()) SWIG_fail;
41281 }
41282 resultobj = SWIG_Py_Void();
41283 return resultobj;
41284 fail:
41285 return NULL;
41286 }
41287
41288
41289 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41290 PyObject *resultobj = 0;
41291 wxMenu *arg1 = (wxMenu *) 0 ;
41292 wxWindow *result = 0 ;
41293 void *argp1 = 0 ;
41294 int res1 = 0 ;
41295 PyObject *swig_obj[1] ;
41296
41297 if (!args) SWIG_fail;
41298 swig_obj[0] = args;
41299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41300 if (!SWIG_IsOK(res1)) {
41301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41302 }
41303 arg1 = reinterpret_cast< wxMenu * >(argp1);
41304 {
41305 PyThreadState* __tstate = wxPyBeginAllowThreads();
41306 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41307 wxPyEndAllowThreads(__tstate);
41308 if (PyErr_Occurred()) SWIG_fail;
41309 }
41310 {
41311 resultobj = wxPyMake_wxObject(result, 0);
41312 }
41313 return resultobj;
41314 fail:
41315 return NULL;
41316 }
41317
41318
41319 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41320 PyObject *resultobj = 0;
41321 wxMenu *arg1 = (wxMenu *) 0 ;
41322 long result;
41323 void *argp1 = 0 ;
41324 int res1 = 0 ;
41325 PyObject *swig_obj[1] ;
41326
41327 if (!args) SWIG_fail;
41328 swig_obj[0] = args;
41329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41330 if (!SWIG_IsOK(res1)) {
41331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41332 }
41333 arg1 = reinterpret_cast< wxMenu * >(argp1);
41334 {
41335 PyThreadState* __tstate = wxPyBeginAllowThreads();
41336 result = (long)((wxMenu const *)arg1)->GetStyle();
41337 wxPyEndAllowThreads(__tstate);
41338 if (PyErr_Occurred()) SWIG_fail;
41339 }
41340 resultobj = SWIG_From_long(static_cast< long >(result));
41341 return resultobj;
41342 fail:
41343 return NULL;
41344 }
41345
41346
41347 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41348 PyObject *resultobj = 0;
41349 wxMenu *arg1 = (wxMenu *) 0 ;
41350 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41351 void *argp1 = 0 ;
41352 int res1 = 0 ;
41353 void *argp2 = 0 ;
41354 int res2 = 0 ;
41355 PyObject * obj0 = 0 ;
41356 PyObject * obj1 = 0 ;
41357 char * kwnames[] = {
41358 (char *) "self",(char *) "source", NULL
41359 };
41360
41361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41363 if (!SWIG_IsOK(res1)) {
41364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41365 }
41366 arg1 = reinterpret_cast< wxMenu * >(argp1);
41367 if (obj1) {
41368 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41369 if (!SWIG_IsOK(res2)) {
41370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41371 }
41372 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41373 }
41374 {
41375 PyThreadState* __tstate = wxPyBeginAllowThreads();
41376 (arg1)->UpdateUI(arg2);
41377 wxPyEndAllowThreads(__tstate);
41378 if (PyErr_Occurred()) SWIG_fail;
41379 }
41380 resultobj = SWIG_Py_Void();
41381 return resultobj;
41382 fail:
41383 return NULL;
41384 }
41385
41386
41387 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41388 PyObject *resultobj = 0;
41389 wxMenu *arg1 = (wxMenu *) 0 ;
41390 wxMenuBar *result = 0 ;
41391 void *argp1 = 0 ;
41392 int res1 = 0 ;
41393 PyObject *swig_obj[1] ;
41394
41395 if (!args) SWIG_fail;
41396 swig_obj[0] = args;
41397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41398 if (!SWIG_IsOK(res1)) {
41399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41400 }
41401 arg1 = reinterpret_cast< wxMenu * >(argp1);
41402 {
41403 PyThreadState* __tstate = wxPyBeginAllowThreads();
41404 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41405 wxPyEndAllowThreads(__tstate);
41406 if (PyErr_Occurred()) SWIG_fail;
41407 }
41408 {
41409 resultobj = wxPyMake_wxObject(result, (bool)0);
41410 }
41411 return resultobj;
41412 fail:
41413 return NULL;
41414 }
41415
41416
41417 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41418 PyObject *resultobj = 0;
41419 wxMenu *arg1 = (wxMenu *) 0 ;
41420 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41421 void *argp1 = 0 ;
41422 int res1 = 0 ;
41423 void *argp2 = 0 ;
41424 int res2 = 0 ;
41425 PyObject * obj0 = 0 ;
41426 PyObject * obj1 = 0 ;
41427 char * kwnames[] = {
41428 (char *) "self",(char *) "menubar", NULL
41429 };
41430
41431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41433 if (!SWIG_IsOK(res1)) {
41434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41435 }
41436 arg1 = reinterpret_cast< wxMenu * >(argp1);
41437 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41438 if (!SWIG_IsOK(res2)) {
41439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41440 }
41441 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41442 {
41443 PyThreadState* __tstate = wxPyBeginAllowThreads();
41444 (arg1)->Attach(arg2);
41445 wxPyEndAllowThreads(__tstate);
41446 if (PyErr_Occurred()) SWIG_fail;
41447 }
41448 resultobj = SWIG_Py_Void();
41449 return resultobj;
41450 fail:
41451 return NULL;
41452 }
41453
41454
41455 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41456 PyObject *resultobj = 0;
41457 wxMenu *arg1 = (wxMenu *) 0 ;
41458 void *argp1 = 0 ;
41459 int res1 = 0 ;
41460 PyObject *swig_obj[1] ;
41461
41462 if (!args) SWIG_fail;
41463 swig_obj[0] = args;
41464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41465 if (!SWIG_IsOK(res1)) {
41466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41467 }
41468 arg1 = reinterpret_cast< wxMenu * >(argp1);
41469 {
41470 PyThreadState* __tstate = wxPyBeginAllowThreads();
41471 (arg1)->Detach();
41472 wxPyEndAllowThreads(__tstate);
41473 if (PyErr_Occurred()) SWIG_fail;
41474 }
41475 resultobj = SWIG_Py_Void();
41476 return resultobj;
41477 fail:
41478 return NULL;
41479 }
41480
41481
41482 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41483 PyObject *resultobj = 0;
41484 wxMenu *arg1 = (wxMenu *) 0 ;
41485 bool result;
41486 void *argp1 = 0 ;
41487 int res1 = 0 ;
41488 PyObject *swig_obj[1] ;
41489
41490 if (!args) SWIG_fail;
41491 swig_obj[0] = args;
41492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41493 if (!SWIG_IsOK(res1)) {
41494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41495 }
41496 arg1 = reinterpret_cast< wxMenu * >(argp1);
41497 {
41498 PyThreadState* __tstate = wxPyBeginAllowThreads();
41499 result = (bool)((wxMenu const *)arg1)->IsAttached();
41500 wxPyEndAllowThreads(__tstate);
41501 if (PyErr_Occurred()) SWIG_fail;
41502 }
41503 {
41504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41505 }
41506 return resultobj;
41507 fail:
41508 return NULL;
41509 }
41510
41511
41512 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41513 PyObject *resultobj = 0;
41514 wxMenu *arg1 = (wxMenu *) 0 ;
41515 wxMenu *arg2 = (wxMenu *) 0 ;
41516 void *argp1 = 0 ;
41517 int res1 = 0 ;
41518 void *argp2 = 0 ;
41519 int res2 = 0 ;
41520 PyObject * obj0 = 0 ;
41521 PyObject * obj1 = 0 ;
41522 char * kwnames[] = {
41523 (char *) "self",(char *) "parent", NULL
41524 };
41525
41526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41528 if (!SWIG_IsOK(res1)) {
41529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41530 }
41531 arg1 = reinterpret_cast< wxMenu * >(argp1);
41532 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41533 if (!SWIG_IsOK(res2)) {
41534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41535 }
41536 arg2 = reinterpret_cast< wxMenu * >(argp2);
41537 {
41538 PyThreadState* __tstate = wxPyBeginAllowThreads();
41539 (arg1)->SetParent(arg2);
41540 wxPyEndAllowThreads(__tstate);
41541 if (PyErr_Occurred()) SWIG_fail;
41542 }
41543 resultobj = SWIG_Py_Void();
41544 return resultobj;
41545 fail:
41546 return NULL;
41547 }
41548
41549
41550 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41551 PyObject *resultobj = 0;
41552 wxMenu *arg1 = (wxMenu *) 0 ;
41553 wxMenu *result = 0 ;
41554 void *argp1 = 0 ;
41555 int res1 = 0 ;
41556 PyObject *swig_obj[1] ;
41557
41558 if (!args) SWIG_fail;
41559 swig_obj[0] = args;
41560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41561 if (!SWIG_IsOK(res1)) {
41562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41563 }
41564 arg1 = reinterpret_cast< wxMenu * >(argp1);
41565 {
41566 PyThreadState* __tstate = wxPyBeginAllowThreads();
41567 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41568 wxPyEndAllowThreads(__tstate);
41569 if (PyErr_Occurred()) SWIG_fail;
41570 }
41571 {
41572 resultobj = wxPyMake_wxObject(result, 0);
41573 }
41574 return resultobj;
41575 fail:
41576 return NULL;
41577 }
41578
41579
41580 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41581 PyObject *obj;
41582 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41583 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41584 return SWIG_Py_Void();
41585 }
41586
41587 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41588 return SWIG_Python_InitShadowInstance(args);
41589 }
41590
41591 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41592 PyObject *resultobj = 0;
41593 long arg1 = (long) 0 ;
41594 wxMenuBar *result = 0 ;
41595 long val1 ;
41596 int ecode1 = 0 ;
41597 PyObject * obj0 = 0 ;
41598 char * kwnames[] = {
41599 (char *) "style", NULL
41600 };
41601
41602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41603 if (obj0) {
41604 ecode1 = SWIG_AsVal_long(obj0, &val1);
41605 if (!SWIG_IsOK(ecode1)) {
41606 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41607 }
41608 arg1 = static_cast< long >(val1);
41609 }
41610 {
41611 if (!wxPyCheckForApp()) SWIG_fail;
41612 PyThreadState* __tstate = wxPyBeginAllowThreads();
41613 result = (wxMenuBar *)new wxMenuBar(arg1);
41614 wxPyEndAllowThreads(__tstate);
41615 if (PyErr_Occurred()) SWIG_fail;
41616 }
41617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41618 return resultobj;
41619 fail:
41620 return NULL;
41621 }
41622
41623
41624 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41625 PyObject *resultobj = 0;
41626 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41627 wxMenu *arg2 = (wxMenu *) 0 ;
41628 wxString *arg3 = 0 ;
41629 bool result;
41630 void *argp1 = 0 ;
41631 int res1 = 0 ;
41632 void *argp2 = 0 ;
41633 int res2 = 0 ;
41634 bool temp3 = false ;
41635 PyObject * obj0 = 0 ;
41636 PyObject * obj1 = 0 ;
41637 PyObject * obj2 = 0 ;
41638 char * kwnames[] = {
41639 (char *) "self",(char *) "menu",(char *) "title", NULL
41640 };
41641
41642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41644 if (!SWIG_IsOK(res1)) {
41645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41646 }
41647 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41648 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41649 if (!SWIG_IsOK(res2)) {
41650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41651 }
41652 arg2 = reinterpret_cast< wxMenu * >(argp2);
41653 {
41654 arg3 = wxString_in_helper(obj2);
41655 if (arg3 == NULL) SWIG_fail;
41656 temp3 = true;
41657 }
41658 {
41659 PyThreadState* __tstate = wxPyBeginAllowThreads();
41660 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41661 wxPyEndAllowThreads(__tstate);
41662 if (PyErr_Occurred()) SWIG_fail;
41663 }
41664 {
41665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41666 }
41667 {
41668 if (temp3)
41669 delete arg3;
41670 }
41671 return resultobj;
41672 fail:
41673 {
41674 if (temp3)
41675 delete arg3;
41676 }
41677 return NULL;
41678 }
41679
41680
41681 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41682 PyObject *resultobj = 0;
41683 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41684 size_t arg2 ;
41685 wxMenu *arg3 = (wxMenu *) 0 ;
41686 wxString *arg4 = 0 ;
41687 bool result;
41688 void *argp1 = 0 ;
41689 int res1 = 0 ;
41690 size_t val2 ;
41691 int ecode2 = 0 ;
41692 void *argp3 = 0 ;
41693 int res3 = 0 ;
41694 bool temp4 = false ;
41695 PyObject * obj0 = 0 ;
41696 PyObject * obj1 = 0 ;
41697 PyObject * obj2 = 0 ;
41698 PyObject * obj3 = 0 ;
41699 char * kwnames[] = {
41700 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41701 };
41702
41703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41705 if (!SWIG_IsOK(res1)) {
41706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41707 }
41708 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41709 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41710 if (!SWIG_IsOK(ecode2)) {
41711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41712 }
41713 arg2 = static_cast< size_t >(val2);
41714 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41715 if (!SWIG_IsOK(res3)) {
41716 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41717 }
41718 arg3 = reinterpret_cast< wxMenu * >(argp3);
41719 {
41720 arg4 = wxString_in_helper(obj3);
41721 if (arg4 == NULL) SWIG_fail;
41722 temp4 = true;
41723 }
41724 {
41725 PyThreadState* __tstate = wxPyBeginAllowThreads();
41726 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41727 wxPyEndAllowThreads(__tstate);
41728 if (PyErr_Occurred()) SWIG_fail;
41729 }
41730 {
41731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41732 }
41733 {
41734 if (temp4)
41735 delete arg4;
41736 }
41737 return resultobj;
41738 fail:
41739 {
41740 if (temp4)
41741 delete arg4;
41742 }
41743 return NULL;
41744 }
41745
41746
41747 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41748 PyObject *resultobj = 0;
41749 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41750 size_t result;
41751 void *argp1 = 0 ;
41752 int res1 = 0 ;
41753 PyObject *swig_obj[1] ;
41754
41755 if (!args) SWIG_fail;
41756 swig_obj[0] = args;
41757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41758 if (!SWIG_IsOK(res1)) {
41759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41760 }
41761 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41762 {
41763 PyThreadState* __tstate = wxPyBeginAllowThreads();
41764 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41765 wxPyEndAllowThreads(__tstate);
41766 if (PyErr_Occurred()) SWIG_fail;
41767 }
41768 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41769 return resultobj;
41770 fail:
41771 return NULL;
41772 }
41773
41774
41775 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41776 PyObject *resultobj = 0;
41777 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41778 size_t arg2 ;
41779 wxMenu *result = 0 ;
41780 void *argp1 = 0 ;
41781 int res1 = 0 ;
41782 size_t val2 ;
41783 int ecode2 = 0 ;
41784 PyObject * obj0 = 0 ;
41785 PyObject * obj1 = 0 ;
41786 char * kwnames[] = {
41787 (char *) "self",(char *) "pos", NULL
41788 };
41789
41790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41792 if (!SWIG_IsOK(res1)) {
41793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41794 }
41795 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41796 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41797 if (!SWIG_IsOK(ecode2)) {
41798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41799 }
41800 arg2 = static_cast< size_t >(val2);
41801 {
41802 PyThreadState* __tstate = wxPyBeginAllowThreads();
41803 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41804 wxPyEndAllowThreads(__tstate);
41805 if (PyErr_Occurred()) SWIG_fail;
41806 }
41807 {
41808 resultobj = wxPyMake_wxObject(result, 0);
41809 }
41810 return resultobj;
41811 fail:
41812 return NULL;
41813 }
41814
41815
41816 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41817 PyObject *resultobj = 0;
41818 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41819 size_t arg2 ;
41820 wxMenu *arg3 = (wxMenu *) 0 ;
41821 wxString *arg4 = 0 ;
41822 wxMenu *result = 0 ;
41823 void *argp1 = 0 ;
41824 int res1 = 0 ;
41825 size_t val2 ;
41826 int ecode2 = 0 ;
41827 void *argp3 = 0 ;
41828 int res3 = 0 ;
41829 bool temp4 = false ;
41830 PyObject * obj0 = 0 ;
41831 PyObject * obj1 = 0 ;
41832 PyObject * obj2 = 0 ;
41833 PyObject * obj3 = 0 ;
41834 char * kwnames[] = {
41835 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41836 };
41837
41838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41840 if (!SWIG_IsOK(res1)) {
41841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41842 }
41843 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41844 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41845 if (!SWIG_IsOK(ecode2)) {
41846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41847 }
41848 arg2 = static_cast< size_t >(val2);
41849 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41850 if (!SWIG_IsOK(res3)) {
41851 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41852 }
41853 arg3 = reinterpret_cast< wxMenu * >(argp3);
41854 {
41855 arg4 = wxString_in_helper(obj3);
41856 if (arg4 == NULL) SWIG_fail;
41857 temp4 = true;
41858 }
41859 {
41860 PyThreadState* __tstate = wxPyBeginAllowThreads();
41861 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41862 wxPyEndAllowThreads(__tstate);
41863 if (PyErr_Occurred()) SWIG_fail;
41864 }
41865 {
41866 resultobj = wxPyMake_wxObject(result, 0);
41867 }
41868 {
41869 if (temp4)
41870 delete arg4;
41871 }
41872 return resultobj;
41873 fail:
41874 {
41875 if (temp4)
41876 delete arg4;
41877 }
41878 return NULL;
41879 }
41880
41881
41882 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41883 PyObject *resultobj = 0;
41884 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41885 size_t arg2 ;
41886 wxMenu *result = 0 ;
41887 void *argp1 = 0 ;
41888 int res1 = 0 ;
41889 size_t val2 ;
41890 int ecode2 = 0 ;
41891 PyObject * obj0 = 0 ;
41892 PyObject * obj1 = 0 ;
41893 char * kwnames[] = {
41894 (char *) "self",(char *) "pos", NULL
41895 };
41896
41897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41899 if (!SWIG_IsOK(res1)) {
41900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41901 }
41902 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41903 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41904 if (!SWIG_IsOK(ecode2)) {
41905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41906 }
41907 arg2 = static_cast< size_t >(val2);
41908 {
41909 PyThreadState* __tstate = wxPyBeginAllowThreads();
41910 result = (wxMenu *)(arg1)->Remove(arg2);
41911 wxPyEndAllowThreads(__tstate);
41912 if (PyErr_Occurred()) SWIG_fail;
41913 }
41914 {
41915 resultobj = wxPyMake_wxObject(result, 0);
41916 }
41917 return resultobj;
41918 fail:
41919 return NULL;
41920 }
41921
41922
41923 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41924 PyObject *resultobj = 0;
41925 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41926 size_t arg2 ;
41927 bool arg3 ;
41928 void *argp1 = 0 ;
41929 int res1 = 0 ;
41930 size_t val2 ;
41931 int ecode2 = 0 ;
41932 bool val3 ;
41933 int ecode3 = 0 ;
41934 PyObject * obj0 = 0 ;
41935 PyObject * obj1 = 0 ;
41936 PyObject * obj2 = 0 ;
41937 char * kwnames[] = {
41938 (char *) "self",(char *) "pos",(char *) "enable", NULL
41939 };
41940
41941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41943 if (!SWIG_IsOK(res1)) {
41944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41945 }
41946 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41947 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41948 if (!SWIG_IsOK(ecode2)) {
41949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41950 }
41951 arg2 = static_cast< size_t >(val2);
41952 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41953 if (!SWIG_IsOK(ecode3)) {
41954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41955 }
41956 arg3 = static_cast< bool >(val3);
41957 {
41958 PyThreadState* __tstate = wxPyBeginAllowThreads();
41959 (arg1)->EnableTop(arg2,arg3);
41960 wxPyEndAllowThreads(__tstate);
41961 if (PyErr_Occurred()) SWIG_fail;
41962 }
41963 resultobj = SWIG_Py_Void();
41964 return resultobj;
41965 fail:
41966 return NULL;
41967 }
41968
41969
41970 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41971 PyObject *resultobj = 0;
41972 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41973 size_t arg2 ;
41974 bool result;
41975 void *argp1 = 0 ;
41976 int res1 = 0 ;
41977 size_t val2 ;
41978 int ecode2 = 0 ;
41979 PyObject * obj0 = 0 ;
41980 PyObject * obj1 = 0 ;
41981 char * kwnames[] = {
41982 (char *) "self",(char *) "pos", NULL
41983 };
41984
41985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41987 if (!SWIG_IsOK(res1)) {
41988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41989 }
41990 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41991 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41992 if (!SWIG_IsOK(ecode2)) {
41993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41994 }
41995 arg2 = static_cast< size_t >(val2);
41996 {
41997 PyThreadState* __tstate = wxPyBeginAllowThreads();
41998 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41999 wxPyEndAllowThreads(__tstate);
42000 if (PyErr_Occurred()) SWIG_fail;
42001 }
42002 {
42003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42004 }
42005 return resultobj;
42006 fail:
42007 return NULL;
42008 }
42009
42010
42011 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42012 PyObject *resultobj = 0;
42013 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42014 size_t arg2 ;
42015 wxString *arg3 = 0 ;
42016 void *argp1 = 0 ;
42017 int res1 = 0 ;
42018 size_t val2 ;
42019 int ecode2 = 0 ;
42020 bool temp3 = false ;
42021 PyObject * obj0 = 0 ;
42022 PyObject * obj1 = 0 ;
42023 PyObject * obj2 = 0 ;
42024 char * kwnames[] = {
42025 (char *) "self",(char *) "pos",(char *) "label", NULL
42026 };
42027
42028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42030 if (!SWIG_IsOK(res1)) {
42031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42032 }
42033 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42034 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42035 if (!SWIG_IsOK(ecode2)) {
42036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42037 }
42038 arg2 = static_cast< size_t >(val2);
42039 {
42040 arg3 = wxString_in_helper(obj2);
42041 if (arg3 == NULL) SWIG_fail;
42042 temp3 = true;
42043 }
42044 {
42045 PyThreadState* __tstate = wxPyBeginAllowThreads();
42046 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42047 wxPyEndAllowThreads(__tstate);
42048 if (PyErr_Occurred()) SWIG_fail;
42049 }
42050 resultobj = SWIG_Py_Void();
42051 {
42052 if (temp3)
42053 delete arg3;
42054 }
42055 return resultobj;
42056 fail:
42057 {
42058 if (temp3)
42059 delete arg3;
42060 }
42061 return NULL;
42062 }
42063
42064
42065 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42066 PyObject *resultobj = 0;
42067 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42068 size_t arg2 ;
42069 wxString result;
42070 void *argp1 = 0 ;
42071 int res1 = 0 ;
42072 size_t val2 ;
42073 int ecode2 = 0 ;
42074 PyObject * obj0 = 0 ;
42075 PyObject * obj1 = 0 ;
42076 char * kwnames[] = {
42077 (char *) "self",(char *) "pos", NULL
42078 };
42079
42080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42082 if (!SWIG_IsOK(res1)) {
42083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42084 }
42085 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42086 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42087 if (!SWIG_IsOK(ecode2)) {
42088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42089 }
42090 arg2 = static_cast< size_t >(val2);
42091 {
42092 PyThreadState* __tstate = wxPyBeginAllowThreads();
42093 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42094 wxPyEndAllowThreads(__tstate);
42095 if (PyErr_Occurred()) SWIG_fail;
42096 }
42097 {
42098 #if wxUSE_UNICODE
42099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42100 #else
42101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42102 #endif
42103 }
42104 return resultobj;
42105 fail:
42106 return NULL;
42107 }
42108
42109
42110 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42111 PyObject *resultobj = 0;
42112 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42113 wxString *arg2 = 0 ;
42114 wxString *arg3 = 0 ;
42115 int result;
42116 void *argp1 = 0 ;
42117 int res1 = 0 ;
42118 bool temp2 = false ;
42119 bool temp3 = false ;
42120 PyObject * obj0 = 0 ;
42121 PyObject * obj1 = 0 ;
42122 PyObject * obj2 = 0 ;
42123 char * kwnames[] = {
42124 (char *) "self",(char *) "menu",(char *) "item", NULL
42125 };
42126
42127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42129 if (!SWIG_IsOK(res1)) {
42130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42131 }
42132 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42133 {
42134 arg2 = wxString_in_helper(obj1);
42135 if (arg2 == NULL) SWIG_fail;
42136 temp2 = true;
42137 }
42138 {
42139 arg3 = wxString_in_helper(obj2);
42140 if (arg3 == NULL) SWIG_fail;
42141 temp3 = true;
42142 }
42143 {
42144 PyThreadState* __tstate = wxPyBeginAllowThreads();
42145 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42146 wxPyEndAllowThreads(__tstate);
42147 if (PyErr_Occurred()) SWIG_fail;
42148 }
42149 resultobj = SWIG_From_int(static_cast< int >(result));
42150 {
42151 if (temp2)
42152 delete arg2;
42153 }
42154 {
42155 if (temp3)
42156 delete arg3;
42157 }
42158 return resultobj;
42159 fail:
42160 {
42161 if (temp2)
42162 delete arg2;
42163 }
42164 {
42165 if (temp3)
42166 delete arg3;
42167 }
42168 return NULL;
42169 }
42170
42171
42172 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42173 PyObject *resultobj = 0;
42174 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42175 int arg2 ;
42176 wxMenuItem *result = 0 ;
42177 void *argp1 = 0 ;
42178 int res1 = 0 ;
42179 int val2 ;
42180 int ecode2 = 0 ;
42181 PyObject * obj0 = 0 ;
42182 PyObject * obj1 = 0 ;
42183 char * kwnames[] = {
42184 (char *) "self",(char *) "id", NULL
42185 };
42186
42187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42189 if (!SWIG_IsOK(res1)) {
42190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42191 }
42192 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42193 ecode2 = SWIG_AsVal_int(obj1, &val2);
42194 if (!SWIG_IsOK(ecode2)) {
42195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42196 }
42197 arg2 = static_cast< int >(val2);
42198 {
42199 PyThreadState* __tstate = wxPyBeginAllowThreads();
42200 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42201 wxPyEndAllowThreads(__tstate);
42202 if (PyErr_Occurred()) SWIG_fail;
42203 }
42204 {
42205 resultobj = wxPyMake_wxObject(result, (bool)0);
42206 }
42207 return resultobj;
42208 fail:
42209 return NULL;
42210 }
42211
42212
42213 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42214 PyObject *resultobj = 0;
42215 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42216 wxString *arg2 = 0 ;
42217 int result;
42218 void *argp1 = 0 ;
42219 int res1 = 0 ;
42220 bool temp2 = false ;
42221 PyObject * obj0 = 0 ;
42222 PyObject * obj1 = 0 ;
42223 char * kwnames[] = {
42224 (char *) "self",(char *) "title", NULL
42225 };
42226
42227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42229 if (!SWIG_IsOK(res1)) {
42230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42231 }
42232 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42233 {
42234 arg2 = wxString_in_helper(obj1);
42235 if (arg2 == NULL) SWIG_fail;
42236 temp2 = true;
42237 }
42238 {
42239 PyThreadState* __tstate = wxPyBeginAllowThreads();
42240 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42241 wxPyEndAllowThreads(__tstate);
42242 if (PyErr_Occurred()) SWIG_fail;
42243 }
42244 resultobj = SWIG_From_int(static_cast< int >(result));
42245 {
42246 if (temp2)
42247 delete arg2;
42248 }
42249 return resultobj;
42250 fail:
42251 {
42252 if (temp2)
42253 delete arg2;
42254 }
42255 return NULL;
42256 }
42257
42258
42259 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42260 PyObject *resultobj = 0;
42261 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42262 int arg2 ;
42263 bool arg3 ;
42264 void *argp1 = 0 ;
42265 int res1 = 0 ;
42266 int val2 ;
42267 int ecode2 = 0 ;
42268 bool val3 ;
42269 int ecode3 = 0 ;
42270 PyObject * obj0 = 0 ;
42271 PyObject * obj1 = 0 ;
42272 PyObject * obj2 = 0 ;
42273 char * kwnames[] = {
42274 (char *) "self",(char *) "id",(char *) "enable", NULL
42275 };
42276
42277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42279 if (!SWIG_IsOK(res1)) {
42280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42281 }
42282 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42283 ecode2 = SWIG_AsVal_int(obj1, &val2);
42284 if (!SWIG_IsOK(ecode2)) {
42285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42286 }
42287 arg2 = static_cast< int >(val2);
42288 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42289 if (!SWIG_IsOK(ecode3)) {
42290 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42291 }
42292 arg3 = static_cast< bool >(val3);
42293 {
42294 PyThreadState* __tstate = wxPyBeginAllowThreads();
42295 (arg1)->Enable(arg2,arg3);
42296 wxPyEndAllowThreads(__tstate);
42297 if (PyErr_Occurred()) SWIG_fail;
42298 }
42299 resultobj = SWIG_Py_Void();
42300 return resultobj;
42301 fail:
42302 return NULL;
42303 }
42304
42305
42306 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42307 PyObject *resultobj = 0;
42308 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42309 int arg2 ;
42310 bool arg3 ;
42311 void *argp1 = 0 ;
42312 int res1 = 0 ;
42313 int val2 ;
42314 int ecode2 = 0 ;
42315 bool val3 ;
42316 int ecode3 = 0 ;
42317 PyObject * obj0 = 0 ;
42318 PyObject * obj1 = 0 ;
42319 PyObject * obj2 = 0 ;
42320 char * kwnames[] = {
42321 (char *) "self",(char *) "id",(char *) "check", NULL
42322 };
42323
42324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42326 if (!SWIG_IsOK(res1)) {
42327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42328 }
42329 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42330 ecode2 = SWIG_AsVal_int(obj1, &val2);
42331 if (!SWIG_IsOK(ecode2)) {
42332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42333 }
42334 arg2 = static_cast< int >(val2);
42335 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42336 if (!SWIG_IsOK(ecode3)) {
42337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42338 }
42339 arg3 = static_cast< bool >(val3);
42340 {
42341 PyThreadState* __tstate = wxPyBeginAllowThreads();
42342 (arg1)->Check(arg2,arg3);
42343 wxPyEndAllowThreads(__tstate);
42344 if (PyErr_Occurred()) SWIG_fail;
42345 }
42346 resultobj = SWIG_Py_Void();
42347 return resultobj;
42348 fail:
42349 return NULL;
42350 }
42351
42352
42353 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42354 PyObject *resultobj = 0;
42355 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42356 int arg2 ;
42357 bool result;
42358 void *argp1 = 0 ;
42359 int res1 = 0 ;
42360 int val2 ;
42361 int ecode2 = 0 ;
42362 PyObject * obj0 = 0 ;
42363 PyObject * obj1 = 0 ;
42364 char * kwnames[] = {
42365 (char *) "self",(char *) "id", NULL
42366 };
42367
42368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42370 if (!SWIG_IsOK(res1)) {
42371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42372 }
42373 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42374 ecode2 = SWIG_AsVal_int(obj1, &val2);
42375 if (!SWIG_IsOK(ecode2)) {
42376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42377 }
42378 arg2 = static_cast< int >(val2);
42379 {
42380 PyThreadState* __tstate = wxPyBeginAllowThreads();
42381 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42382 wxPyEndAllowThreads(__tstate);
42383 if (PyErr_Occurred()) SWIG_fail;
42384 }
42385 {
42386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42387 }
42388 return resultobj;
42389 fail:
42390 return NULL;
42391 }
42392
42393
42394 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42395 PyObject *resultobj = 0;
42396 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42397 int arg2 ;
42398 bool result;
42399 void *argp1 = 0 ;
42400 int res1 = 0 ;
42401 int val2 ;
42402 int ecode2 = 0 ;
42403 PyObject * obj0 = 0 ;
42404 PyObject * obj1 = 0 ;
42405 char * kwnames[] = {
42406 (char *) "self",(char *) "id", NULL
42407 };
42408
42409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42411 if (!SWIG_IsOK(res1)) {
42412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42413 }
42414 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42415 ecode2 = SWIG_AsVal_int(obj1, &val2);
42416 if (!SWIG_IsOK(ecode2)) {
42417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42418 }
42419 arg2 = static_cast< int >(val2);
42420 {
42421 PyThreadState* __tstate = wxPyBeginAllowThreads();
42422 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42423 wxPyEndAllowThreads(__tstate);
42424 if (PyErr_Occurred()) SWIG_fail;
42425 }
42426 {
42427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42428 }
42429 return resultobj;
42430 fail:
42431 return NULL;
42432 }
42433
42434
42435 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42436 PyObject *resultobj = 0;
42437 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42438 int arg2 ;
42439 wxString *arg3 = 0 ;
42440 void *argp1 = 0 ;
42441 int res1 = 0 ;
42442 int val2 ;
42443 int ecode2 = 0 ;
42444 bool temp3 = false ;
42445 PyObject * obj0 = 0 ;
42446 PyObject * obj1 = 0 ;
42447 PyObject * obj2 = 0 ;
42448 char * kwnames[] = {
42449 (char *) "self",(char *) "id",(char *) "label", NULL
42450 };
42451
42452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42454 if (!SWIG_IsOK(res1)) {
42455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42456 }
42457 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42458 ecode2 = SWIG_AsVal_int(obj1, &val2);
42459 if (!SWIG_IsOK(ecode2)) {
42460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42461 }
42462 arg2 = static_cast< int >(val2);
42463 {
42464 arg3 = wxString_in_helper(obj2);
42465 if (arg3 == NULL) SWIG_fail;
42466 temp3 = true;
42467 }
42468 {
42469 PyThreadState* __tstate = wxPyBeginAllowThreads();
42470 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42471 wxPyEndAllowThreads(__tstate);
42472 if (PyErr_Occurred()) SWIG_fail;
42473 }
42474 resultobj = SWIG_Py_Void();
42475 {
42476 if (temp3)
42477 delete arg3;
42478 }
42479 return resultobj;
42480 fail:
42481 {
42482 if (temp3)
42483 delete arg3;
42484 }
42485 return NULL;
42486 }
42487
42488
42489 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42490 PyObject *resultobj = 0;
42491 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42492 int arg2 ;
42493 wxString result;
42494 void *argp1 = 0 ;
42495 int res1 = 0 ;
42496 int val2 ;
42497 int ecode2 = 0 ;
42498 PyObject * obj0 = 0 ;
42499 PyObject * obj1 = 0 ;
42500 char * kwnames[] = {
42501 (char *) "self",(char *) "id", NULL
42502 };
42503
42504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42506 if (!SWIG_IsOK(res1)) {
42507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42508 }
42509 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42510 ecode2 = SWIG_AsVal_int(obj1, &val2);
42511 if (!SWIG_IsOK(ecode2)) {
42512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42513 }
42514 arg2 = static_cast< int >(val2);
42515 {
42516 PyThreadState* __tstate = wxPyBeginAllowThreads();
42517 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42518 wxPyEndAllowThreads(__tstate);
42519 if (PyErr_Occurred()) SWIG_fail;
42520 }
42521 {
42522 #if wxUSE_UNICODE
42523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42524 #else
42525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42526 #endif
42527 }
42528 return resultobj;
42529 fail:
42530 return NULL;
42531 }
42532
42533
42534 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42535 PyObject *resultobj = 0;
42536 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42537 int arg2 ;
42538 wxString *arg3 = 0 ;
42539 void *argp1 = 0 ;
42540 int res1 = 0 ;
42541 int val2 ;
42542 int ecode2 = 0 ;
42543 bool temp3 = false ;
42544 PyObject * obj0 = 0 ;
42545 PyObject * obj1 = 0 ;
42546 PyObject * obj2 = 0 ;
42547 char * kwnames[] = {
42548 (char *) "self",(char *) "id",(char *) "helpString", NULL
42549 };
42550
42551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42553 if (!SWIG_IsOK(res1)) {
42554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42555 }
42556 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42557 ecode2 = SWIG_AsVal_int(obj1, &val2);
42558 if (!SWIG_IsOK(ecode2)) {
42559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42560 }
42561 arg2 = static_cast< int >(val2);
42562 {
42563 arg3 = wxString_in_helper(obj2);
42564 if (arg3 == NULL) SWIG_fail;
42565 temp3 = true;
42566 }
42567 {
42568 PyThreadState* __tstate = wxPyBeginAllowThreads();
42569 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42570 wxPyEndAllowThreads(__tstate);
42571 if (PyErr_Occurred()) SWIG_fail;
42572 }
42573 resultobj = SWIG_Py_Void();
42574 {
42575 if (temp3)
42576 delete arg3;
42577 }
42578 return resultobj;
42579 fail:
42580 {
42581 if (temp3)
42582 delete arg3;
42583 }
42584 return NULL;
42585 }
42586
42587
42588 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42589 PyObject *resultobj = 0;
42590 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42591 int arg2 ;
42592 wxString result;
42593 void *argp1 = 0 ;
42594 int res1 = 0 ;
42595 int val2 ;
42596 int ecode2 = 0 ;
42597 PyObject * obj0 = 0 ;
42598 PyObject * obj1 = 0 ;
42599 char * kwnames[] = {
42600 (char *) "self",(char *) "id", NULL
42601 };
42602
42603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42605 if (!SWIG_IsOK(res1)) {
42606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42607 }
42608 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42609 ecode2 = SWIG_AsVal_int(obj1, &val2);
42610 if (!SWIG_IsOK(ecode2)) {
42611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42612 }
42613 arg2 = static_cast< int >(val2);
42614 {
42615 PyThreadState* __tstate = wxPyBeginAllowThreads();
42616 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42617 wxPyEndAllowThreads(__tstate);
42618 if (PyErr_Occurred()) SWIG_fail;
42619 }
42620 {
42621 #if wxUSE_UNICODE
42622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42623 #else
42624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42625 #endif
42626 }
42627 return resultobj;
42628 fail:
42629 return NULL;
42630 }
42631
42632
42633 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42634 PyObject *resultobj = 0;
42635 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42636 wxFrame *result = 0 ;
42637 void *argp1 = 0 ;
42638 int res1 = 0 ;
42639 PyObject *swig_obj[1] ;
42640
42641 if (!args) SWIG_fail;
42642 swig_obj[0] = args;
42643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42644 if (!SWIG_IsOK(res1)) {
42645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42646 }
42647 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42648 {
42649 PyThreadState* __tstate = wxPyBeginAllowThreads();
42650 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42651 wxPyEndAllowThreads(__tstate);
42652 if (PyErr_Occurred()) SWIG_fail;
42653 }
42654 {
42655 resultobj = wxPyMake_wxObject(result, (bool)0);
42656 }
42657 return resultobj;
42658 fail:
42659 return NULL;
42660 }
42661
42662
42663 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42664 PyObject *resultobj = 0;
42665 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42666 bool result;
42667 void *argp1 = 0 ;
42668 int res1 = 0 ;
42669 PyObject *swig_obj[1] ;
42670
42671 if (!args) SWIG_fail;
42672 swig_obj[0] = args;
42673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42674 if (!SWIG_IsOK(res1)) {
42675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42676 }
42677 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42678 {
42679 PyThreadState* __tstate = wxPyBeginAllowThreads();
42680 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42681 wxPyEndAllowThreads(__tstate);
42682 if (PyErr_Occurred()) SWIG_fail;
42683 }
42684 {
42685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42686 }
42687 return resultobj;
42688 fail:
42689 return NULL;
42690 }
42691
42692
42693 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42694 PyObject *resultobj = 0;
42695 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42696 wxFrame *arg2 = (wxFrame *) 0 ;
42697 void *argp1 = 0 ;
42698 int res1 = 0 ;
42699 void *argp2 = 0 ;
42700 int res2 = 0 ;
42701 PyObject * obj0 = 0 ;
42702 PyObject * obj1 = 0 ;
42703 char * kwnames[] = {
42704 (char *) "self",(char *) "frame", NULL
42705 };
42706
42707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42709 if (!SWIG_IsOK(res1)) {
42710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42711 }
42712 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42713 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42714 if (!SWIG_IsOK(res2)) {
42715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42716 }
42717 arg2 = reinterpret_cast< wxFrame * >(argp2);
42718 {
42719 PyThreadState* __tstate = wxPyBeginAllowThreads();
42720 (arg1)->Attach(arg2);
42721 wxPyEndAllowThreads(__tstate);
42722 if (PyErr_Occurred()) SWIG_fail;
42723 }
42724 resultobj = SWIG_Py_Void();
42725 return resultobj;
42726 fail:
42727 return NULL;
42728 }
42729
42730
42731 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42732 PyObject *resultobj = 0;
42733 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42734 void *argp1 = 0 ;
42735 int res1 = 0 ;
42736 PyObject *swig_obj[1] ;
42737
42738 if (!args) SWIG_fail;
42739 swig_obj[0] = args;
42740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42741 if (!SWIG_IsOK(res1)) {
42742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42743 }
42744 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42745 {
42746 PyThreadState* __tstate = wxPyBeginAllowThreads();
42747 (arg1)->Detach();
42748 wxPyEndAllowThreads(__tstate);
42749 if (PyErr_Occurred()) SWIG_fail;
42750 }
42751 resultobj = SWIG_Py_Void();
42752 return resultobj;
42753 fail:
42754 return NULL;
42755 }
42756
42757
42758 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42759 PyObject *resultobj = 0;
42760 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42761 void *argp1 = 0 ;
42762 int res1 = 0 ;
42763 PyObject *swig_obj[1] ;
42764
42765 if (!args) SWIG_fail;
42766 swig_obj[0] = args;
42767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42768 if (!SWIG_IsOK(res1)) {
42769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42770 }
42771 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42772 {
42773 PyThreadState* __tstate = wxPyBeginAllowThreads();
42774 (arg1)->UpdateMenus();
42775 wxPyEndAllowThreads(__tstate);
42776 if (PyErr_Occurred()) SWIG_fail;
42777 }
42778 resultobj = SWIG_Py_Void();
42779 return resultobj;
42780 fail:
42781 return NULL;
42782 }
42783
42784
42785 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42786 PyObject *resultobj = 0;
42787 bool arg1 ;
42788 bool val1 ;
42789 int ecode1 = 0 ;
42790 PyObject * obj0 = 0 ;
42791 char * kwnames[] = {
42792 (char *) "enable", NULL
42793 };
42794
42795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42796 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42797 if (!SWIG_IsOK(ecode1)) {
42798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42799 }
42800 arg1 = static_cast< bool >(val1);
42801 {
42802 PyThreadState* __tstate = wxPyBeginAllowThreads();
42803 wxMenuBar_SetAutoWindowMenu(arg1);
42804 wxPyEndAllowThreads(__tstate);
42805 if (PyErr_Occurred()) SWIG_fail;
42806 }
42807 resultobj = SWIG_Py_Void();
42808 return resultobj;
42809 fail:
42810 return NULL;
42811 }
42812
42813
42814 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42815 PyObject *resultobj = 0;
42816 bool result;
42817
42818 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42819 {
42820 PyThreadState* __tstate = wxPyBeginAllowThreads();
42821 result = (bool)wxMenuBar_GetAutoWindowMenu();
42822 wxPyEndAllowThreads(__tstate);
42823 if (PyErr_Occurred()) SWIG_fail;
42824 }
42825 {
42826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42827 }
42828 return resultobj;
42829 fail:
42830 return NULL;
42831 }
42832
42833
42834 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42835 PyObject *obj;
42836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42837 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42838 return SWIG_Py_Void();
42839 }
42840
42841 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42842 return SWIG_Python_InitShadowInstance(args);
42843 }
42844
42845 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42846 PyObject *resultobj = 0;
42847 wxMenu *arg1 = (wxMenu *) NULL ;
42848 int arg2 = (int) wxID_ANY ;
42849 wxString const &arg3_defvalue = wxPyEmptyString ;
42850 wxString *arg3 = (wxString *) &arg3_defvalue ;
42851 wxString const &arg4_defvalue = wxPyEmptyString ;
42852 wxString *arg4 = (wxString *) &arg4_defvalue ;
42853 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42854 wxMenu *arg6 = (wxMenu *) NULL ;
42855 wxMenuItem *result = 0 ;
42856 void *argp1 = 0 ;
42857 int res1 = 0 ;
42858 int val2 ;
42859 int ecode2 = 0 ;
42860 bool temp3 = false ;
42861 bool temp4 = false ;
42862 int val5 ;
42863 int ecode5 = 0 ;
42864 void *argp6 = 0 ;
42865 int res6 = 0 ;
42866 PyObject * obj0 = 0 ;
42867 PyObject * obj1 = 0 ;
42868 PyObject * obj2 = 0 ;
42869 PyObject * obj3 = 0 ;
42870 PyObject * obj4 = 0 ;
42871 PyObject * obj5 = 0 ;
42872 char * kwnames[] = {
42873 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42874 };
42875
42876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42877 if (obj0) {
42878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42879 if (!SWIG_IsOK(res1)) {
42880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42881 }
42882 arg1 = reinterpret_cast< wxMenu * >(argp1);
42883 }
42884 if (obj1) {
42885 ecode2 = SWIG_AsVal_int(obj1, &val2);
42886 if (!SWIG_IsOK(ecode2)) {
42887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42888 }
42889 arg2 = static_cast< int >(val2);
42890 }
42891 if (obj2) {
42892 {
42893 arg3 = wxString_in_helper(obj2);
42894 if (arg3 == NULL) SWIG_fail;
42895 temp3 = true;
42896 }
42897 }
42898 if (obj3) {
42899 {
42900 arg4 = wxString_in_helper(obj3);
42901 if (arg4 == NULL) SWIG_fail;
42902 temp4 = true;
42903 }
42904 }
42905 if (obj4) {
42906 ecode5 = SWIG_AsVal_int(obj4, &val5);
42907 if (!SWIG_IsOK(ecode5)) {
42908 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42909 }
42910 arg5 = static_cast< wxItemKind >(val5);
42911 }
42912 if (obj5) {
42913 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42914 if (!SWIG_IsOK(res6)) {
42915 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42916 }
42917 arg6 = reinterpret_cast< wxMenu * >(argp6);
42918 }
42919 {
42920 PyThreadState* __tstate = wxPyBeginAllowThreads();
42921 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42922 wxPyEndAllowThreads(__tstate);
42923 if (PyErr_Occurred()) SWIG_fail;
42924 }
42925 {
42926 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42927 }
42928 {
42929 if (temp3)
42930 delete arg3;
42931 }
42932 {
42933 if (temp4)
42934 delete arg4;
42935 }
42936 return resultobj;
42937 fail:
42938 {
42939 if (temp3)
42940 delete arg3;
42941 }
42942 {
42943 if (temp4)
42944 delete arg4;
42945 }
42946 return NULL;
42947 }
42948
42949
42950 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42951 PyObject *resultobj = 0;
42952 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42953 void *argp1 = 0 ;
42954 int res1 = 0 ;
42955 PyObject *swig_obj[1] ;
42956
42957 if (!args) SWIG_fail;
42958 swig_obj[0] = args;
42959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42960 if (!SWIG_IsOK(res1)) {
42961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42962 }
42963 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42964 {
42965 PyThreadState* __tstate = wxPyBeginAllowThreads();
42966 delete arg1;
42967
42968 wxPyEndAllowThreads(__tstate);
42969 if (PyErr_Occurred()) SWIG_fail;
42970 }
42971 resultobj = SWIG_Py_Void();
42972 return resultobj;
42973 fail:
42974 return NULL;
42975 }
42976
42977
42978 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42979 PyObject *resultobj = 0;
42980 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42981 wxMenu *result = 0 ;
42982 void *argp1 = 0 ;
42983 int res1 = 0 ;
42984 PyObject *swig_obj[1] ;
42985
42986 if (!args) SWIG_fail;
42987 swig_obj[0] = args;
42988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42989 if (!SWIG_IsOK(res1)) {
42990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42991 }
42992 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42993 {
42994 PyThreadState* __tstate = wxPyBeginAllowThreads();
42995 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42996 wxPyEndAllowThreads(__tstate);
42997 if (PyErr_Occurred()) SWIG_fail;
42998 }
42999 {
43000 resultobj = wxPyMake_wxObject(result, 0);
43001 }
43002 return resultobj;
43003 fail:
43004 return NULL;
43005 }
43006
43007
43008 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43009 PyObject *resultobj = 0;
43010 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43011 wxMenu *arg2 = (wxMenu *) 0 ;
43012 void *argp1 = 0 ;
43013 int res1 = 0 ;
43014 void *argp2 = 0 ;
43015 int res2 = 0 ;
43016 PyObject * obj0 = 0 ;
43017 PyObject * obj1 = 0 ;
43018 char * kwnames[] = {
43019 (char *) "self",(char *) "menu", NULL
43020 };
43021
43022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43024 if (!SWIG_IsOK(res1)) {
43025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43026 }
43027 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43028 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43029 if (!SWIG_IsOK(res2)) {
43030 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43031 }
43032 arg2 = reinterpret_cast< wxMenu * >(argp2);
43033 {
43034 PyThreadState* __tstate = wxPyBeginAllowThreads();
43035 (arg1)->SetMenu(arg2);
43036 wxPyEndAllowThreads(__tstate);
43037 if (PyErr_Occurred()) SWIG_fail;
43038 }
43039 resultobj = SWIG_Py_Void();
43040 return resultobj;
43041 fail:
43042 return NULL;
43043 }
43044
43045
43046 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43047 PyObject *resultobj = 0;
43048 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43049 int arg2 ;
43050 void *argp1 = 0 ;
43051 int res1 = 0 ;
43052 int val2 ;
43053 int ecode2 = 0 ;
43054 PyObject * obj0 = 0 ;
43055 PyObject * obj1 = 0 ;
43056 char * kwnames[] = {
43057 (char *) "self",(char *) "id", NULL
43058 };
43059
43060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43062 if (!SWIG_IsOK(res1)) {
43063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43064 }
43065 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43066 ecode2 = SWIG_AsVal_int(obj1, &val2);
43067 if (!SWIG_IsOK(ecode2)) {
43068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43069 }
43070 arg2 = static_cast< int >(val2);
43071 {
43072 PyThreadState* __tstate = wxPyBeginAllowThreads();
43073 (arg1)->SetId(arg2);
43074 wxPyEndAllowThreads(__tstate);
43075 if (PyErr_Occurred()) SWIG_fail;
43076 }
43077 resultobj = SWIG_Py_Void();
43078 return resultobj;
43079 fail:
43080 return NULL;
43081 }
43082
43083
43084 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43085 PyObject *resultobj = 0;
43086 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43087 int result;
43088 void *argp1 = 0 ;
43089 int res1 = 0 ;
43090 PyObject *swig_obj[1] ;
43091
43092 if (!args) SWIG_fail;
43093 swig_obj[0] = args;
43094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43095 if (!SWIG_IsOK(res1)) {
43096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43097 }
43098 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43099 {
43100 PyThreadState* __tstate = wxPyBeginAllowThreads();
43101 result = (int)((wxMenuItem const *)arg1)->GetId();
43102 wxPyEndAllowThreads(__tstate);
43103 if (PyErr_Occurred()) SWIG_fail;
43104 }
43105 resultobj = SWIG_From_int(static_cast< int >(result));
43106 return resultobj;
43107 fail:
43108 return NULL;
43109 }
43110
43111
43112 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43113 PyObject *resultobj = 0;
43114 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43115 bool result;
43116 void *argp1 = 0 ;
43117 int res1 = 0 ;
43118 PyObject *swig_obj[1] ;
43119
43120 if (!args) SWIG_fail;
43121 swig_obj[0] = args;
43122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43123 if (!SWIG_IsOK(res1)) {
43124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43125 }
43126 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43127 {
43128 PyThreadState* __tstate = wxPyBeginAllowThreads();
43129 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43130 wxPyEndAllowThreads(__tstate);
43131 if (PyErr_Occurred()) SWIG_fail;
43132 }
43133 {
43134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43135 }
43136 return resultobj;
43137 fail:
43138 return NULL;
43139 }
43140
43141
43142 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43143 PyObject *resultobj = 0;
43144 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43145 wxString *arg2 = 0 ;
43146 void *argp1 = 0 ;
43147 int res1 = 0 ;
43148 bool temp2 = false ;
43149 PyObject * obj0 = 0 ;
43150 PyObject * obj1 = 0 ;
43151 char * kwnames[] = {
43152 (char *) "self",(char *) "str", NULL
43153 };
43154
43155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43157 if (!SWIG_IsOK(res1)) {
43158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43159 }
43160 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43161 {
43162 arg2 = wxString_in_helper(obj1);
43163 if (arg2 == NULL) SWIG_fail;
43164 temp2 = true;
43165 }
43166 {
43167 PyThreadState* __tstate = wxPyBeginAllowThreads();
43168 (arg1)->SetText((wxString const &)*arg2);
43169 wxPyEndAllowThreads(__tstate);
43170 if (PyErr_Occurred()) SWIG_fail;
43171 }
43172 resultobj = SWIG_Py_Void();
43173 {
43174 if (temp2)
43175 delete arg2;
43176 }
43177 return resultobj;
43178 fail:
43179 {
43180 if (temp2)
43181 delete arg2;
43182 }
43183 return NULL;
43184 }
43185
43186
43187 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43188 PyObject *resultobj = 0;
43189 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43190 wxString result;
43191 void *argp1 = 0 ;
43192 int res1 = 0 ;
43193 PyObject *swig_obj[1] ;
43194
43195 if (!args) SWIG_fail;
43196 swig_obj[0] = args;
43197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43198 if (!SWIG_IsOK(res1)) {
43199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43200 }
43201 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43202 {
43203 PyThreadState* __tstate = wxPyBeginAllowThreads();
43204 result = ((wxMenuItem const *)arg1)->GetLabel();
43205 wxPyEndAllowThreads(__tstate);
43206 if (PyErr_Occurred()) SWIG_fail;
43207 }
43208 {
43209 #if wxUSE_UNICODE
43210 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43211 #else
43212 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43213 #endif
43214 }
43215 return resultobj;
43216 fail:
43217 return NULL;
43218 }
43219
43220
43221 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43222 PyObject *resultobj = 0;
43223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43224 wxString *result = 0 ;
43225 void *argp1 = 0 ;
43226 int res1 = 0 ;
43227 PyObject *swig_obj[1] ;
43228
43229 if (!args) SWIG_fail;
43230 swig_obj[0] = args;
43231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43232 if (!SWIG_IsOK(res1)) {
43233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43234 }
43235 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43236 {
43237 PyThreadState* __tstate = wxPyBeginAllowThreads();
43238 {
43239 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43240 result = (wxString *) &_result_ref;
43241 }
43242 wxPyEndAllowThreads(__tstate);
43243 if (PyErr_Occurred()) SWIG_fail;
43244 }
43245 {
43246 #if wxUSE_UNICODE
43247 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43248 #else
43249 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43250 #endif
43251 }
43252 return resultobj;
43253 fail:
43254 return NULL;
43255 }
43256
43257
43258 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43259 PyObject *resultobj = 0;
43260 wxString *arg1 = 0 ;
43261 wxString result;
43262 bool temp1 = false ;
43263 PyObject * obj0 = 0 ;
43264 char * kwnames[] = {
43265 (char *) "text", NULL
43266 };
43267
43268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43269 {
43270 arg1 = wxString_in_helper(obj0);
43271 if (arg1 == NULL) SWIG_fail;
43272 temp1 = true;
43273 }
43274 {
43275 PyThreadState* __tstate = wxPyBeginAllowThreads();
43276 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43277 wxPyEndAllowThreads(__tstate);
43278 if (PyErr_Occurred()) SWIG_fail;
43279 }
43280 {
43281 #if wxUSE_UNICODE
43282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43283 #else
43284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43285 #endif
43286 }
43287 {
43288 if (temp1)
43289 delete arg1;
43290 }
43291 return resultobj;
43292 fail:
43293 {
43294 if (temp1)
43295 delete arg1;
43296 }
43297 return NULL;
43298 }
43299
43300
43301 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43302 PyObject *resultobj = 0;
43303 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43304 wxItemKind result;
43305 void *argp1 = 0 ;
43306 int res1 = 0 ;
43307 PyObject *swig_obj[1] ;
43308
43309 if (!args) SWIG_fail;
43310 swig_obj[0] = args;
43311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43312 if (!SWIG_IsOK(res1)) {
43313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43314 }
43315 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43316 {
43317 PyThreadState* __tstate = wxPyBeginAllowThreads();
43318 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43319 wxPyEndAllowThreads(__tstate);
43320 if (PyErr_Occurred()) SWIG_fail;
43321 }
43322 resultobj = SWIG_From_int(static_cast< int >(result));
43323 return resultobj;
43324 fail:
43325 return NULL;
43326 }
43327
43328
43329 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43330 PyObject *resultobj = 0;
43331 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43332 wxItemKind arg2 ;
43333 void *argp1 = 0 ;
43334 int res1 = 0 ;
43335 int val2 ;
43336 int ecode2 = 0 ;
43337 PyObject * obj0 = 0 ;
43338 PyObject * obj1 = 0 ;
43339 char * kwnames[] = {
43340 (char *) "self",(char *) "kind", NULL
43341 };
43342
43343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43345 if (!SWIG_IsOK(res1)) {
43346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43347 }
43348 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43349 ecode2 = SWIG_AsVal_int(obj1, &val2);
43350 if (!SWIG_IsOK(ecode2)) {
43351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43352 }
43353 arg2 = static_cast< wxItemKind >(val2);
43354 {
43355 PyThreadState* __tstate = wxPyBeginAllowThreads();
43356 (arg1)->SetKind(arg2);
43357 wxPyEndAllowThreads(__tstate);
43358 if (PyErr_Occurred()) SWIG_fail;
43359 }
43360 resultobj = SWIG_Py_Void();
43361 return resultobj;
43362 fail:
43363 return NULL;
43364 }
43365
43366
43367 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43368 PyObject *resultobj = 0;
43369 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43370 bool arg2 ;
43371 void *argp1 = 0 ;
43372 int res1 = 0 ;
43373 bool val2 ;
43374 int ecode2 = 0 ;
43375 PyObject * obj0 = 0 ;
43376 PyObject * obj1 = 0 ;
43377 char * kwnames[] = {
43378 (char *) "self",(char *) "checkable", NULL
43379 };
43380
43381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43383 if (!SWIG_IsOK(res1)) {
43384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43385 }
43386 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43387 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43388 if (!SWIG_IsOK(ecode2)) {
43389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43390 }
43391 arg2 = static_cast< bool >(val2);
43392 {
43393 PyThreadState* __tstate = wxPyBeginAllowThreads();
43394 (arg1)->SetCheckable(arg2);
43395 wxPyEndAllowThreads(__tstate);
43396 if (PyErr_Occurred()) SWIG_fail;
43397 }
43398 resultobj = SWIG_Py_Void();
43399 return resultobj;
43400 fail:
43401 return NULL;
43402 }
43403
43404
43405 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43406 PyObject *resultobj = 0;
43407 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43408 bool result;
43409 void *argp1 = 0 ;
43410 int res1 = 0 ;
43411 PyObject *swig_obj[1] ;
43412
43413 if (!args) SWIG_fail;
43414 swig_obj[0] = args;
43415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43416 if (!SWIG_IsOK(res1)) {
43417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43418 }
43419 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43420 {
43421 PyThreadState* __tstate = wxPyBeginAllowThreads();
43422 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43423 wxPyEndAllowThreads(__tstate);
43424 if (PyErr_Occurred()) SWIG_fail;
43425 }
43426 {
43427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43428 }
43429 return resultobj;
43430 fail:
43431 return NULL;
43432 }
43433
43434
43435 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43436 PyObject *resultobj = 0;
43437 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43438 bool result;
43439 void *argp1 = 0 ;
43440 int res1 = 0 ;
43441 PyObject *swig_obj[1] ;
43442
43443 if (!args) SWIG_fail;
43444 swig_obj[0] = args;
43445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43446 if (!SWIG_IsOK(res1)) {
43447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43448 }
43449 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43450 {
43451 PyThreadState* __tstate = wxPyBeginAllowThreads();
43452 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43453 wxPyEndAllowThreads(__tstate);
43454 if (PyErr_Occurred()) SWIG_fail;
43455 }
43456 {
43457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43458 }
43459 return resultobj;
43460 fail:
43461 return NULL;
43462 }
43463
43464
43465 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43466 PyObject *resultobj = 0;
43467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43468 wxMenu *arg2 = (wxMenu *) 0 ;
43469 void *argp1 = 0 ;
43470 int res1 = 0 ;
43471 void *argp2 = 0 ;
43472 int res2 = 0 ;
43473 PyObject * obj0 = 0 ;
43474 PyObject * obj1 = 0 ;
43475 char * kwnames[] = {
43476 (char *) "self",(char *) "menu", NULL
43477 };
43478
43479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43481 if (!SWIG_IsOK(res1)) {
43482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43483 }
43484 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43485 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43486 if (!SWIG_IsOK(res2)) {
43487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43488 }
43489 arg2 = reinterpret_cast< wxMenu * >(argp2);
43490 {
43491 PyThreadState* __tstate = wxPyBeginAllowThreads();
43492 (arg1)->SetSubMenu(arg2);
43493 wxPyEndAllowThreads(__tstate);
43494 if (PyErr_Occurred()) SWIG_fail;
43495 }
43496 resultobj = SWIG_Py_Void();
43497 return resultobj;
43498 fail:
43499 return NULL;
43500 }
43501
43502
43503 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43504 PyObject *resultobj = 0;
43505 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43506 wxMenu *result = 0 ;
43507 void *argp1 = 0 ;
43508 int res1 = 0 ;
43509 PyObject *swig_obj[1] ;
43510
43511 if (!args) SWIG_fail;
43512 swig_obj[0] = args;
43513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43514 if (!SWIG_IsOK(res1)) {
43515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43516 }
43517 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43518 {
43519 PyThreadState* __tstate = wxPyBeginAllowThreads();
43520 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43521 wxPyEndAllowThreads(__tstate);
43522 if (PyErr_Occurred()) SWIG_fail;
43523 }
43524 {
43525 resultobj = wxPyMake_wxObject(result, 0);
43526 }
43527 return resultobj;
43528 fail:
43529 return NULL;
43530 }
43531
43532
43533 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43534 PyObject *resultobj = 0;
43535 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43536 bool arg2 = (bool) true ;
43537 void *argp1 = 0 ;
43538 int res1 = 0 ;
43539 bool val2 ;
43540 int ecode2 = 0 ;
43541 PyObject * obj0 = 0 ;
43542 PyObject * obj1 = 0 ;
43543 char * kwnames[] = {
43544 (char *) "self",(char *) "enable", NULL
43545 };
43546
43547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43549 if (!SWIG_IsOK(res1)) {
43550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43551 }
43552 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43553 if (obj1) {
43554 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43555 if (!SWIG_IsOK(ecode2)) {
43556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43557 }
43558 arg2 = static_cast< bool >(val2);
43559 }
43560 {
43561 PyThreadState* __tstate = wxPyBeginAllowThreads();
43562 (arg1)->Enable(arg2);
43563 wxPyEndAllowThreads(__tstate);
43564 if (PyErr_Occurred()) SWIG_fail;
43565 }
43566 resultobj = SWIG_Py_Void();
43567 return resultobj;
43568 fail:
43569 return NULL;
43570 }
43571
43572
43573 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43574 PyObject *resultobj = 0;
43575 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43576 bool result;
43577 void *argp1 = 0 ;
43578 int res1 = 0 ;
43579 PyObject *swig_obj[1] ;
43580
43581 if (!args) SWIG_fail;
43582 swig_obj[0] = args;
43583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43584 if (!SWIG_IsOK(res1)) {
43585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43586 }
43587 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43588 {
43589 PyThreadState* __tstate = wxPyBeginAllowThreads();
43590 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43591 wxPyEndAllowThreads(__tstate);
43592 if (PyErr_Occurred()) SWIG_fail;
43593 }
43594 {
43595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43596 }
43597 return resultobj;
43598 fail:
43599 return NULL;
43600 }
43601
43602
43603 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43604 PyObject *resultobj = 0;
43605 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43606 bool arg2 = (bool) true ;
43607 void *argp1 = 0 ;
43608 int res1 = 0 ;
43609 bool val2 ;
43610 int ecode2 = 0 ;
43611 PyObject * obj0 = 0 ;
43612 PyObject * obj1 = 0 ;
43613 char * kwnames[] = {
43614 (char *) "self",(char *) "check", NULL
43615 };
43616
43617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43619 if (!SWIG_IsOK(res1)) {
43620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43621 }
43622 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43623 if (obj1) {
43624 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43625 if (!SWIG_IsOK(ecode2)) {
43626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43627 }
43628 arg2 = static_cast< bool >(val2);
43629 }
43630 {
43631 PyThreadState* __tstate = wxPyBeginAllowThreads();
43632 (arg1)->Check(arg2);
43633 wxPyEndAllowThreads(__tstate);
43634 if (PyErr_Occurred()) SWIG_fail;
43635 }
43636 resultobj = SWIG_Py_Void();
43637 return resultobj;
43638 fail:
43639 return NULL;
43640 }
43641
43642
43643 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43644 PyObject *resultobj = 0;
43645 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43646 bool result;
43647 void *argp1 = 0 ;
43648 int res1 = 0 ;
43649 PyObject *swig_obj[1] ;
43650
43651 if (!args) SWIG_fail;
43652 swig_obj[0] = args;
43653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43654 if (!SWIG_IsOK(res1)) {
43655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43656 }
43657 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43658 {
43659 PyThreadState* __tstate = wxPyBeginAllowThreads();
43660 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43661 wxPyEndAllowThreads(__tstate);
43662 if (PyErr_Occurred()) SWIG_fail;
43663 }
43664 {
43665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43666 }
43667 return resultobj;
43668 fail:
43669 return NULL;
43670 }
43671
43672
43673 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43674 PyObject *resultobj = 0;
43675 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43676 void *argp1 = 0 ;
43677 int res1 = 0 ;
43678 PyObject *swig_obj[1] ;
43679
43680 if (!args) SWIG_fail;
43681 swig_obj[0] = args;
43682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43683 if (!SWIG_IsOK(res1)) {
43684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43685 }
43686 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43687 {
43688 PyThreadState* __tstate = wxPyBeginAllowThreads();
43689 (arg1)->Toggle();
43690 wxPyEndAllowThreads(__tstate);
43691 if (PyErr_Occurred()) SWIG_fail;
43692 }
43693 resultobj = SWIG_Py_Void();
43694 return resultobj;
43695 fail:
43696 return NULL;
43697 }
43698
43699
43700 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43701 PyObject *resultobj = 0;
43702 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43703 wxString *arg2 = 0 ;
43704 void *argp1 = 0 ;
43705 int res1 = 0 ;
43706 bool temp2 = false ;
43707 PyObject * obj0 = 0 ;
43708 PyObject * obj1 = 0 ;
43709 char * kwnames[] = {
43710 (char *) "self",(char *) "str", NULL
43711 };
43712
43713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43715 if (!SWIG_IsOK(res1)) {
43716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43717 }
43718 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43719 {
43720 arg2 = wxString_in_helper(obj1);
43721 if (arg2 == NULL) SWIG_fail;
43722 temp2 = true;
43723 }
43724 {
43725 PyThreadState* __tstate = wxPyBeginAllowThreads();
43726 (arg1)->SetHelp((wxString const &)*arg2);
43727 wxPyEndAllowThreads(__tstate);
43728 if (PyErr_Occurred()) SWIG_fail;
43729 }
43730 resultobj = SWIG_Py_Void();
43731 {
43732 if (temp2)
43733 delete arg2;
43734 }
43735 return resultobj;
43736 fail:
43737 {
43738 if (temp2)
43739 delete arg2;
43740 }
43741 return NULL;
43742 }
43743
43744
43745 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43746 PyObject *resultobj = 0;
43747 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43748 wxString *result = 0 ;
43749 void *argp1 = 0 ;
43750 int res1 = 0 ;
43751 PyObject *swig_obj[1] ;
43752
43753 if (!args) SWIG_fail;
43754 swig_obj[0] = args;
43755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43756 if (!SWIG_IsOK(res1)) {
43757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43758 }
43759 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43760 {
43761 PyThreadState* __tstate = wxPyBeginAllowThreads();
43762 {
43763 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43764 result = (wxString *) &_result_ref;
43765 }
43766 wxPyEndAllowThreads(__tstate);
43767 if (PyErr_Occurred()) SWIG_fail;
43768 }
43769 {
43770 #if wxUSE_UNICODE
43771 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43772 #else
43773 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43774 #endif
43775 }
43776 return resultobj;
43777 fail:
43778 return NULL;
43779 }
43780
43781
43782 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43783 PyObject *resultobj = 0;
43784 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43785 wxAcceleratorEntry *result = 0 ;
43786 void *argp1 = 0 ;
43787 int res1 = 0 ;
43788 PyObject *swig_obj[1] ;
43789
43790 if (!args) SWIG_fail;
43791 swig_obj[0] = args;
43792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43793 if (!SWIG_IsOK(res1)) {
43794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43795 }
43796 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43797 {
43798 PyThreadState* __tstate = wxPyBeginAllowThreads();
43799 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43800 wxPyEndAllowThreads(__tstate);
43801 if (PyErr_Occurred()) SWIG_fail;
43802 }
43803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43804 return resultobj;
43805 fail:
43806 return NULL;
43807 }
43808
43809
43810 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43811 PyObject *resultobj = 0;
43812 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43813 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43814 void *argp1 = 0 ;
43815 int res1 = 0 ;
43816 void *argp2 = 0 ;
43817 int res2 = 0 ;
43818 PyObject * obj0 = 0 ;
43819 PyObject * obj1 = 0 ;
43820 char * kwnames[] = {
43821 (char *) "self",(char *) "accel", NULL
43822 };
43823
43824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43826 if (!SWIG_IsOK(res1)) {
43827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43828 }
43829 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43830 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43831 if (!SWIG_IsOK(res2)) {
43832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43833 }
43834 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43835 {
43836 PyThreadState* __tstate = wxPyBeginAllowThreads();
43837 (arg1)->SetAccel(arg2);
43838 wxPyEndAllowThreads(__tstate);
43839 if (PyErr_Occurred()) SWIG_fail;
43840 }
43841 resultobj = SWIG_Py_Void();
43842 return resultobj;
43843 fail:
43844 return NULL;
43845 }
43846
43847
43848 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43849 PyObject *resultobj = 0;
43850 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43851 wxBitmap *arg2 = 0 ;
43852 void *argp1 = 0 ;
43853 int res1 = 0 ;
43854 void *argp2 = 0 ;
43855 int res2 = 0 ;
43856 PyObject * obj0 = 0 ;
43857 PyObject * obj1 = 0 ;
43858 char * kwnames[] = {
43859 (char *) "self",(char *) "bitmap", NULL
43860 };
43861
43862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43864 if (!SWIG_IsOK(res1)) {
43865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43866 }
43867 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43868 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43869 if (!SWIG_IsOK(res2)) {
43870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43871 }
43872 if (!argp2) {
43873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43874 }
43875 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43876 {
43877 PyThreadState* __tstate = wxPyBeginAllowThreads();
43878 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43879 wxPyEndAllowThreads(__tstate);
43880 if (PyErr_Occurred()) SWIG_fail;
43881 }
43882 resultobj = SWIG_Py_Void();
43883 return resultobj;
43884 fail:
43885 return NULL;
43886 }
43887
43888
43889 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43890 PyObject *resultobj = 0;
43891 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43892 wxBitmap *result = 0 ;
43893 void *argp1 = 0 ;
43894 int res1 = 0 ;
43895 PyObject *swig_obj[1] ;
43896
43897 if (!args) SWIG_fail;
43898 swig_obj[0] = args;
43899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43900 if (!SWIG_IsOK(res1)) {
43901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43902 }
43903 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43904 {
43905 PyThreadState* __tstate = wxPyBeginAllowThreads();
43906 {
43907 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43908 result = (wxBitmap *) &_result_ref;
43909 }
43910 wxPyEndAllowThreads(__tstate);
43911 if (PyErr_Occurred()) SWIG_fail;
43912 }
43913 {
43914 wxBitmap* resultptr = new wxBitmap(*result);
43915 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43916 }
43917 return resultobj;
43918 fail:
43919 return NULL;
43920 }
43921
43922
43923 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43924 PyObject *resultobj = 0;
43925 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43926 wxFont *arg2 = 0 ;
43927 void *argp1 = 0 ;
43928 int res1 = 0 ;
43929 void *argp2 = 0 ;
43930 int res2 = 0 ;
43931 PyObject * obj0 = 0 ;
43932 PyObject * obj1 = 0 ;
43933 char * kwnames[] = {
43934 (char *) "self",(char *) "font", NULL
43935 };
43936
43937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43939 if (!SWIG_IsOK(res1)) {
43940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43941 }
43942 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43943 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43944 if (!SWIG_IsOK(res2)) {
43945 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43946 }
43947 if (!argp2) {
43948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43949 }
43950 arg2 = reinterpret_cast< wxFont * >(argp2);
43951 {
43952 PyThreadState* __tstate = wxPyBeginAllowThreads();
43953 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43954 wxPyEndAllowThreads(__tstate);
43955 if (PyErr_Occurred()) SWIG_fail;
43956 }
43957 resultobj = SWIG_Py_Void();
43958 return resultobj;
43959 fail:
43960 return NULL;
43961 }
43962
43963
43964 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43965 PyObject *resultobj = 0;
43966 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43967 wxFont result;
43968 void *argp1 = 0 ;
43969 int res1 = 0 ;
43970 PyObject *swig_obj[1] ;
43971
43972 if (!args) SWIG_fail;
43973 swig_obj[0] = args;
43974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43975 if (!SWIG_IsOK(res1)) {
43976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43977 }
43978 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43979 {
43980 PyThreadState* __tstate = wxPyBeginAllowThreads();
43981 result = wxMenuItem_GetFont(arg1);
43982 wxPyEndAllowThreads(__tstate);
43983 if (PyErr_Occurred()) SWIG_fail;
43984 }
43985 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43986 return resultobj;
43987 fail:
43988 return NULL;
43989 }
43990
43991
43992 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43993 PyObject *resultobj = 0;
43994 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43995 wxColour *arg2 = 0 ;
43996 void *argp1 = 0 ;
43997 int res1 = 0 ;
43998 wxColour temp2 ;
43999 PyObject * obj0 = 0 ;
44000 PyObject * obj1 = 0 ;
44001 char * kwnames[] = {
44002 (char *) "self",(char *) "colText", NULL
44003 };
44004
44005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44007 if (!SWIG_IsOK(res1)) {
44008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44009 }
44010 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44011 {
44012 arg2 = &temp2;
44013 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44014 }
44015 {
44016 PyThreadState* __tstate = wxPyBeginAllowThreads();
44017 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44018 wxPyEndAllowThreads(__tstate);
44019 if (PyErr_Occurred()) SWIG_fail;
44020 }
44021 resultobj = SWIG_Py_Void();
44022 return resultobj;
44023 fail:
44024 return NULL;
44025 }
44026
44027
44028 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44029 PyObject *resultobj = 0;
44030 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44031 wxColour result;
44032 void *argp1 = 0 ;
44033 int res1 = 0 ;
44034 PyObject *swig_obj[1] ;
44035
44036 if (!args) SWIG_fail;
44037 swig_obj[0] = args;
44038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44039 if (!SWIG_IsOK(res1)) {
44040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44041 }
44042 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44043 {
44044 PyThreadState* __tstate = wxPyBeginAllowThreads();
44045 result = wxMenuItem_GetTextColour(arg1);
44046 wxPyEndAllowThreads(__tstate);
44047 if (PyErr_Occurred()) SWIG_fail;
44048 }
44049 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44050 return resultobj;
44051 fail:
44052 return NULL;
44053 }
44054
44055
44056 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44057 PyObject *resultobj = 0;
44058 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44059 wxColour *arg2 = 0 ;
44060 void *argp1 = 0 ;
44061 int res1 = 0 ;
44062 wxColour temp2 ;
44063 PyObject * obj0 = 0 ;
44064 PyObject * obj1 = 0 ;
44065 char * kwnames[] = {
44066 (char *) "self",(char *) "colBack", NULL
44067 };
44068
44069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44071 if (!SWIG_IsOK(res1)) {
44072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44073 }
44074 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44075 {
44076 arg2 = &temp2;
44077 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44078 }
44079 {
44080 PyThreadState* __tstate = wxPyBeginAllowThreads();
44081 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44082 wxPyEndAllowThreads(__tstate);
44083 if (PyErr_Occurred()) SWIG_fail;
44084 }
44085 resultobj = SWIG_Py_Void();
44086 return resultobj;
44087 fail:
44088 return NULL;
44089 }
44090
44091
44092 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44093 PyObject *resultobj = 0;
44094 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44095 wxColour result;
44096 void *argp1 = 0 ;
44097 int res1 = 0 ;
44098 PyObject *swig_obj[1] ;
44099
44100 if (!args) SWIG_fail;
44101 swig_obj[0] = args;
44102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44103 if (!SWIG_IsOK(res1)) {
44104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44105 }
44106 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44107 {
44108 PyThreadState* __tstate = wxPyBeginAllowThreads();
44109 result = wxMenuItem_GetBackgroundColour(arg1);
44110 wxPyEndAllowThreads(__tstate);
44111 if (PyErr_Occurred()) SWIG_fail;
44112 }
44113 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44114 return resultobj;
44115 fail:
44116 return NULL;
44117 }
44118
44119
44120 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44121 PyObject *resultobj = 0;
44122 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44123 wxBitmap *arg2 = 0 ;
44124 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44125 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44126 void *argp1 = 0 ;
44127 int res1 = 0 ;
44128 void *argp2 = 0 ;
44129 int res2 = 0 ;
44130 void *argp3 = 0 ;
44131 int res3 = 0 ;
44132 PyObject * obj0 = 0 ;
44133 PyObject * obj1 = 0 ;
44134 PyObject * obj2 = 0 ;
44135 char * kwnames[] = {
44136 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44137 };
44138
44139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44141 if (!SWIG_IsOK(res1)) {
44142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44143 }
44144 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44145 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44146 if (!SWIG_IsOK(res2)) {
44147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44148 }
44149 if (!argp2) {
44150 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44151 }
44152 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44153 if (obj2) {
44154 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44155 if (!SWIG_IsOK(res3)) {
44156 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44157 }
44158 if (!argp3) {
44159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44160 }
44161 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44162 }
44163 {
44164 PyThreadState* __tstate = wxPyBeginAllowThreads();
44165 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44166 wxPyEndAllowThreads(__tstate);
44167 if (PyErr_Occurred()) SWIG_fail;
44168 }
44169 resultobj = SWIG_Py_Void();
44170 return resultobj;
44171 fail:
44172 return NULL;
44173 }
44174
44175
44176 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44177 PyObject *resultobj = 0;
44178 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44179 wxBitmap *arg2 = 0 ;
44180 void *argp1 = 0 ;
44181 int res1 = 0 ;
44182 void *argp2 = 0 ;
44183 int res2 = 0 ;
44184 PyObject * obj0 = 0 ;
44185 PyObject * obj1 = 0 ;
44186 char * kwnames[] = {
44187 (char *) "self",(char *) "bmpDisabled", NULL
44188 };
44189
44190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44192 if (!SWIG_IsOK(res1)) {
44193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44194 }
44195 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44196 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44197 if (!SWIG_IsOK(res2)) {
44198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44199 }
44200 if (!argp2) {
44201 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44202 }
44203 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44204 {
44205 PyThreadState* __tstate = wxPyBeginAllowThreads();
44206 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44207 wxPyEndAllowThreads(__tstate);
44208 if (PyErr_Occurred()) SWIG_fail;
44209 }
44210 resultobj = SWIG_Py_Void();
44211 return resultobj;
44212 fail:
44213 return NULL;
44214 }
44215
44216
44217 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44218 PyObject *resultobj = 0;
44219 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44220 wxBitmap *result = 0 ;
44221 void *argp1 = 0 ;
44222 int res1 = 0 ;
44223 PyObject *swig_obj[1] ;
44224
44225 if (!args) SWIG_fail;
44226 swig_obj[0] = args;
44227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44228 if (!SWIG_IsOK(res1)) {
44229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44230 }
44231 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44232 {
44233 PyThreadState* __tstate = wxPyBeginAllowThreads();
44234 {
44235 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44236 result = (wxBitmap *) &_result_ref;
44237 }
44238 wxPyEndAllowThreads(__tstate);
44239 if (PyErr_Occurred()) SWIG_fail;
44240 }
44241 {
44242 wxBitmap* resultptr = new wxBitmap(*result);
44243 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44244 }
44245 return resultobj;
44246 fail:
44247 return NULL;
44248 }
44249
44250
44251 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44252 PyObject *resultobj = 0;
44253 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44254 int arg2 ;
44255 void *argp1 = 0 ;
44256 int res1 = 0 ;
44257 int val2 ;
44258 int ecode2 = 0 ;
44259 PyObject * obj0 = 0 ;
44260 PyObject * obj1 = 0 ;
44261 char * kwnames[] = {
44262 (char *) "self",(char *) "nWidth", NULL
44263 };
44264
44265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44267 if (!SWIG_IsOK(res1)) {
44268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44269 }
44270 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44271 ecode2 = SWIG_AsVal_int(obj1, &val2);
44272 if (!SWIG_IsOK(ecode2)) {
44273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44274 }
44275 arg2 = static_cast< int >(val2);
44276 {
44277 PyThreadState* __tstate = wxPyBeginAllowThreads();
44278 wxMenuItem_SetMarginWidth(arg1,arg2);
44279 wxPyEndAllowThreads(__tstate);
44280 if (PyErr_Occurred()) SWIG_fail;
44281 }
44282 resultobj = SWIG_Py_Void();
44283 return resultobj;
44284 fail:
44285 return NULL;
44286 }
44287
44288
44289 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44290 PyObject *resultobj = 0;
44291 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44292 int result;
44293 void *argp1 = 0 ;
44294 int res1 = 0 ;
44295 PyObject *swig_obj[1] ;
44296
44297 if (!args) SWIG_fail;
44298 swig_obj[0] = args;
44299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44300 if (!SWIG_IsOK(res1)) {
44301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44302 }
44303 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44304 {
44305 PyThreadState* __tstate = wxPyBeginAllowThreads();
44306 result = (int)wxMenuItem_GetMarginWidth(arg1);
44307 wxPyEndAllowThreads(__tstate);
44308 if (PyErr_Occurred()) SWIG_fail;
44309 }
44310 resultobj = SWIG_From_int(static_cast< int >(result));
44311 return resultobj;
44312 fail:
44313 return NULL;
44314 }
44315
44316
44317 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44318 PyObject *resultobj = 0;
44319 int result;
44320
44321 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44322 {
44323 PyThreadState* __tstate = wxPyBeginAllowThreads();
44324 result = (int)wxMenuItem_GetDefaultMarginWidth();
44325 wxPyEndAllowThreads(__tstate);
44326 if (PyErr_Occurred()) SWIG_fail;
44327 }
44328 resultobj = SWIG_From_int(static_cast< int >(result));
44329 return resultobj;
44330 fail:
44331 return NULL;
44332 }
44333
44334
44335 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44336 PyObject *resultobj = 0;
44337 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44338 bool result;
44339 void *argp1 = 0 ;
44340 int res1 = 0 ;
44341 PyObject *swig_obj[1] ;
44342
44343 if (!args) SWIG_fail;
44344 swig_obj[0] = args;
44345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44346 if (!SWIG_IsOK(res1)) {
44347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44348 }
44349 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44350 {
44351 PyThreadState* __tstate = wxPyBeginAllowThreads();
44352 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
44353 wxPyEndAllowThreads(__tstate);
44354 if (PyErr_Occurred()) SWIG_fail;
44355 }
44356 {
44357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44358 }
44359 return resultobj;
44360 fail:
44361 return NULL;
44362 }
44363
44364
44365 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44366 PyObject *resultobj = 0;
44367 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44368 bool arg2 = (bool) true ;
44369 void *argp1 = 0 ;
44370 int res1 = 0 ;
44371 bool val2 ;
44372 int ecode2 = 0 ;
44373 PyObject * obj0 = 0 ;
44374 PyObject * obj1 = 0 ;
44375 char * kwnames[] = {
44376 (char *) "self",(char *) "ownerDrawn", NULL
44377 };
44378
44379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44381 if (!SWIG_IsOK(res1)) {
44382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44383 }
44384 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44385 if (obj1) {
44386 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44387 if (!SWIG_IsOK(ecode2)) {
44388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44389 }
44390 arg2 = static_cast< bool >(val2);
44391 }
44392 {
44393 PyThreadState* __tstate = wxPyBeginAllowThreads();
44394 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44395 wxPyEndAllowThreads(__tstate);
44396 if (PyErr_Occurred()) SWIG_fail;
44397 }
44398 resultobj = SWIG_Py_Void();
44399 return resultobj;
44400 fail:
44401 return NULL;
44402 }
44403
44404
44405 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44406 PyObject *resultobj = 0;
44407 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44408 void *argp1 = 0 ;
44409 int res1 = 0 ;
44410 PyObject *swig_obj[1] ;
44411
44412 if (!args) SWIG_fail;
44413 swig_obj[0] = args;
44414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44415 if (!SWIG_IsOK(res1)) {
44416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44417 }
44418 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44419 {
44420 PyThreadState* __tstate = wxPyBeginAllowThreads();
44421 wxMenuItem_ResetOwnerDrawn(arg1);
44422 wxPyEndAllowThreads(__tstate);
44423 if (PyErr_Occurred()) SWIG_fail;
44424 }
44425 resultobj = SWIG_Py_Void();
44426 return resultobj;
44427 fail:
44428 return NULL;
44429 }
44430
44431
44432 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44433 PyObject *obj;
44434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44435 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44436 return SWIG_Py_Void();
44437 }
44438
44439 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44440 return SWIG_Python_InitShadowInstance(args);
44441 }
44442
44443 SWIGINTERN int ControlNameStr_set(PyObject *) {
44444 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44445 return 1;
44446 }
44447
44448
44449 SWIGINTERN PyObject *ControlNameStr_get(void) {
44450 PyObject *pyobj = 0;
44451
44452 {
44453 #if wxUSE_UNICODE
44454 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44455 #else
44456 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44457 #endif
44458 }
44459 return pyobj;
44460 }
44461
44462
44463 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44464 PyObject *resultobj = 0;
44465 wxWindow *arg1 = (wxWindow *) 0 ;
44466 int arg2 = (int) -1 ;
44467 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44468 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44469 wxSize const &arg4_defvalue = wxDefaultSize ;
44470 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44471 long arg5 = (long) 0 ;
44472 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44473 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44474 wxString const &arg7_defvalue = wxPyControlNameStr ;
44475 wxString *arg7 = (wxString *) &arg7_defvalue ;
44476 wxControl *result = 0 ;
44477 void *argp1 = 0 ;
44478 int res1 = 0 ;
44479 int val2 ;
44480 int ecode2 = 0 ;
44481 wxPoint temp3 ;
44482 wxSize temp4 ;
44483 long val5 ;
44484 int ecode5 = 0 ;
44485 void *argp6 = 0 ;
44486 int res6 = 0 ;
44487 bool temp7 = false ;
44488 PyObject * obj0 = 0 ;
44489 PyObject * obj1 = 0 ;
44490 PyObject * obj2 = 0 ;
44491 PyObject * obj3 = 0 ;
44492 PyObject * obj4 = 0 ;
44493 PyObject * obj5 = 0 ;
44494 PyObject * obj6 = 0 ;
44495 char * kwnames[] = {
44496 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44497 };
44498
44499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44501 if (!SWIG_IsOK(res1)) {
44502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44503 }
44504 arg1 = reinterpret_cast< wxWindow * >(argp1);
44505 if (obj1) {
44506 ecode2 = SWIG_AsVal_int(obj1, &val2);
44507 if (!SWIG_IsOK(ecode2)) {
44508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44509 }
44510 arg2 = static_cast< int >(val2);
44511 }
44512 if (obj2) {
44513 {
44514 arg3 = &temp3;
44515 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44516 }
44517 }
44518 if (obj3) {
44519 {
44520 arg4 = &temp4;
44521 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44522 }
44523 }
44524 if (obj4) {
44525 ecode5 = SWIG_AsVal_long(obj4, &val5);
44526 if (!SWIG_IsOK(ecode5)) {
44527 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44528 }
44529 arg5 = static_cast< long >(val5);
44530 }
44531 if (obj5) {
44532 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44533 if (!SWIG_IsOK(res6)) {
44534 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44535 }
44536 if (!argp6) {
44537 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44538 }
44539 arg6 = reinterpret_cast< wxValidator * >(argp6);
44540 }
44541 if (obj6) {
44542 {
44543 arg7 = wxString_in_helper(obj6);
44544 if (arg7 == NULL) SWIG_fail;
44545 temp7 = true;
44546 }
44547 }
44548 {
44549 if (!wxPyCheckForApp()) SWIG_fail;
44550 PyThreadState* __tstate = wxPyBeginAllowThreads();
44551 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44552 wxPyEndAllowThreads(__tstate);
44553 if (PyErr_Occurred()) SWIG_fail;
44554 }
44555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44556 {
44557 if (temp7)
44558 delete arg7;
44559 }
44560 return resultobj;
44561 fail:
44562 {
44563 if (temp7)
44564 delete arg7;
44565 }
44566 return NULL;
44567 }
44568
44569
44570 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44571 PyObject *resultobj = 0;
44572 wxControl *result = 0 ;
44573
44574 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44575 {
44576 if (!wxPyCheckForApp()) SWIG_fail;
44577 PyThreadState* __tstate = wxPyBeginAllowThreads();
44578 result = (wxControl *)new wxControl();
44579 wxPyEndAllowThreads(__tstate);
44580 if (PyErr_Occurred()) SWIG_fail;
44581 }
44582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44583 return resultobj;
44584 fail:
44585 return NULL;
44586 }
44587
44588
44589 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44590 PyObject *resultobj = 0;
44591 wxControl *arg1 = (wxControl *) 0 ;
44592 wxWindow *arg2 = (wxWindow *) 0 ;
44593 int arg3 = (int) -1 ;
44594 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44595 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44596 wxSize const &arg5_defvalue = wxDefaultSize ;
44597 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44598 long arg6 = (long) 0 ;
44599 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44600 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44601 wxString const &arg8_defvalue = wxPyControlNameStr ;
44602 wxString *arg8 = (wxString *) &arg8_defvalue ;
44603 bool result;
44604 void *argp1 = 0 ;
44605 int res1 = 0 ;
44606 void *argp2 = 0 ;
44607 int res2 = 0 ;
44608 int val3 ;
44609 int ecode3 = 0 ;
44610 wxPoint temp4 ;
44611 wxSize temp5 ;
44612 long val6 ;
44613 int ecode6 = 0 ;
44614 void *argp7 = 0 ;
44615 int res7 = 0 ;
44616 bool temp8 = false ;
44617 PyObject * obj0 = 0 ;
44618 PyObject * obj1 = 0 ;
44619 PyObject * obj2 = 0 ;
44620 PyObject * obj3 = 0 ;
44621 PyObject * obj4 = 0 ;
44622 PyObject * obj5 = 0 ;
44623 PyObject * obj6 = 0 ;
44624 PyObject * obj7 = 0 ;
44625 char * kwnames[] = {
44626 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44627 };
44628
44629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44631 if (!SWIG_IsOK(res1)) {
44632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44633 }
44634 arg1 = reinterpret_cast< wxControl * >(argp1);
44635 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44636 if (!SWIG_IsOK(res2)) {
44637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44638 }
44639 arg2 = reinterpret_cast< wxWindow * >(argp2);
44640 if (obj2) {
44641 ecode3 = SWIG_AsVal_int(obj2, &val3);
44642 if (!SWIG_IsOK(ecode3)) {
44643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44644 }
44645 arg3 = static_cast< int >(val3);
44646 }
44647 if (obj3) {
44648 {
44649 arg4 = &temp4;
44650 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44651 }
44652 }
44653 if (obj4) {
44654 {
44655 arg5 = &temp5;
44656 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44657 }
44658 }
44659 if (obj5) {
44660 ecode6 = SWIG_AsVal_long(obj5, &val6);
44661 if (!SWIG_IsOK(ecode6)) {
44662 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44663 }
44664 arg6 = static_cast< long >(val6);
44665 }
44666 if (obj6) {
44667 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44668 if (!SWIG_IsOK(res7)) {
44669 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44670 }
44671 if (!argp7) {
44672 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44673 }
44674 arg7 = reinterpret_cast< wxValidator * >(argp7);
44675 }
44676 if (obj7) {
44677 {
44678 arg8 = wxString_in_helper(obj7);
44679 if (arg8 == NULL) SWIG_fail;
44680 temp8 = true;
44681 }
44682 }
44683 {
44684 PyThreadState* __tstate = wxPyBeginAllowThreads();
44685 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44686 wxPyEndAllowThreads(__tstate);
44687 if (PyErr_Occurred()) SWIG_fail;
44688 }
44689 {
44690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44691 }
44692 {
44693 if (temp8)
44694 delete arg8;
44695 }
44696 return resultobj;
44697 fail:
44698 {
44699 if (temp8)
44700 delete arg8;
44701 }
44702 return NULL;
44703 }
44704
44705
44706 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44707 PyObject *resultobj = 0;
44708 wxControl *arg1 = (wxControl *) 0 ;
44709 int result;
44710 void *argp1 = 0 ;
44711 int res1 = 0 ;
44712 PyObject *swig_obj[1] ;
44713
44714 if (!args) SWIG_fail;
44715 swig_obj[0] = args;
44716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44717 if (!SWIG_IsOK(res1)) {
44718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44719 }
44720 arg1 = reinterpret_cast< wxControl * >(argp1);
44721 {
44722 PyThreadState* __tstate = wxPyBeginAllowThreads();
44723 result = (int)((wxControl const *)arg1)->GetAlignment();
44724 wxPyEndAllowThreads(__tstate);
44725 if (PyErr_Occurred()) SWIG_fail;
44726 }
44727 resultobj = SWIG_From_int(static_cast< int >(result));
44728 return resultobj;
44729 fail:
44730 return NULL;
44731 }
44732
44733
44734 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44735 PyObject *resultobj = 0;
44736 wxControl *arg1 = (wxControl *) 0 ;
44737 wxString result;
44738 void *argp1 = 0 ;
44739 int res1 = 0 ;
44740 PyObject *swig_obj[1] ;
44741
44742 if (!args) SWIG_fail;
44743 swig_obj[0] = args;
44744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44745 if (!SWIG_IsOK(res1)) {
44746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44747 }
44748 arg1 = reinterpret_cast< wxControl * >(argp1);
44749 {
44750 PyThreadState* __tstate = wxPyBeginAllowThreads();
44751 result = ((wxControl const *)arg1)->GetLabelText();
44752 wxPyEndAllowThreads(__tstate);
44753 if (PyErr_Occurred()) SWIG_fail;
44754 }
44755 {
44756 #if wxUSE_UNICODE
44757 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44758 #else
44759 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44760 #endif
44761 }
44762 return resultobj;
44763 fail:
44764 return NULL;
44765 }
44766
44767
44768 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44769 PyObject *resultobj = 0;
44770 wxControl *arg1 = (wxControl *) 0 ;
44771 wxCommandEvent *arg2 = 0 ;
44772 void *argp1 = 0 ;
44773 int res1 = 0 ;
44774 void *argp2 = 0 ;
44775 int res2 = 0 ;
44776 PyObject * obj0 = 0 ;
44777 PyObject * obj1 = 0 ;
44778 char * kwnames[] = {
44779 (char *) "self",(char *) "event", NULL
44780 };
44781
44782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44784 if (!SWIG_IsOK(res1)) {
44785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44786 }
44787 arg1 = reinterpret_cast< wxControl * >(argp1);
44788 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44789 if (!SWIG_IsOK(res2)) {
44790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44791 }
44792 if (!argp2) {
44793 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44794 }
44795 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44796 {
44797 PyThreadState* __tstate = wxPyBeginAllowThreads();
44798 (arg1)->Command(*arg2);
44799 wxPyEndAllowThreads(__tstate);
44800 if (PyErr_Occurred()) SWIG_fail;
44801 }
44802 resultobj = SWIG_Py_Void();
44803 return resultobj;
44804 fail:
44805 return NULL;
44806 }
44807
44808
44809 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44810 PyObject *resultobj = 0;
44811 wxControl *arg1 = (wxControl *) 0 ;
44812 wxString result;
44813 void *argp1 = 0 ;
44814 int res1 = 0 ;
44815 PyObject *swig_obj[1] ;
44816
44817 if (!args) SWIG_fail;
44818 swig_obj[0] = args;
44819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44820 if (!SWIG_IsOK(res1)) {
44821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44822 }
44823 arg1 = reinterpret_cast< wxControl * >(argp1);
44824 {
44825 PyThreadState* __tstate = wxPyBeginAllowThreads();
44826 result = (arg1)->GetLabel();
44827 wxPyEndAllowThreads(__tstate);
44828 if (PyErr_Occurred()) SWIG_fail;
44829 }
44830 {
44831 #if wxUSE_UNICODE
44832 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44833 #else
44834 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44835 #endif
44836 }
44837 return resultobj;
44838 fail:
44839 return NULL;
44840 }
44841
44842
44843 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44844 PyObject *resultobj = 0;
44845 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44846 SwigValueWrapper<wxVisualAttributes > result;
44847 int val1 ;
44848 int ecode1 = 0 ;
44849 PyObject * obj0 = 0 ;
44850 char * kwnames[] = {
44851 (char *) "variant", NULL
44852 };
44853
44854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44855 if (obj0) {
44856 ecode1 = SWIG_AsVal_int(obj0, &val1);
44857 if (!SWIG_IsOK(ecode1)) {
44858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44859 }
44860 arg1 = static_cast< wxWindowVariant >(val1);
44861 }
44862 {
44863 if (!wxPyCheckForApp()) SWIG_fail;
44864 PyThreadState* __tstate = wxPyBeginAllowThreads();
44865 result = wxControl::GetClassDefaultAttributes(arg1);
44866 wxPyEndAllowThreads(__tstate);
44867 if (PyErr_Occurred()) SWIG_fail;
44868 }
44869 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44870 return resultobj;
44871 fail:
44872 return NULL;
44873 }
44874
44875
44876 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44877 PyObject *obj;
44878 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44879 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44880 return SWIG_Py_Void();
44881 }
44882
44883 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44884 return SWIG_Python_InitShadowInstance(args);
44885 }
44886
44887 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44888 PyObject *resultobj = 0;
44889 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44890 wxString *arg2 = 0 ;
44891 PyObject *arg3 = (PyObject *) NULL ;
44892 int result;
44893 void *argp1 = 0 ;
44894 int res1 = 0 ;
44895 bool temp2 = false ;
44896 PyObject * obj0 = 0 ;
44897 PyObject * obj1 = 0 ;
44898 PyObject * obj2 = 0 ;
44899 char * kwnames[] = {
44900 (char *) "self",(char *) "item",(char *) "clientData", NULL
44901 };
44902
44903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44905 if (!SWIG_IsOK(res1)) {
44906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44907 }
44908 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44909 {
44910 arg2 = wxString_in_helper(obj1);
44911 if (arg2 == NULL) SWIG_fail;
44912 temp2 = true;
44913 }
44914 if (obj2) {
44915 arg3 = obj2;
44916 }
44917 {
44918 PyThreadState* __tstate = wxPyBeginAllowThreads();
44919 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44920 wxPyEndAllowThreads(__tstate);
44921 if (PyErr_Occurred()) SWIG_fail;
44922 }
44923 resultobj = SWIG_From_int(static_cast< int >(result));
44924 {
44925 if (temp2)
44926 delete arg2;
44927 }
44928 return resultobj;
44929 fail:
44930 {
44931 if (temp2)
44932 delete arg2;
44933 }
44934 return NULL;
44935 }
44936
44937
44938 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44939 PyObject *resultobj = 0;
44940 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44941 wxArrayString *arg2 = 0 ;
44942 void *argp1 = 0 ;
44943 int res1 = 0 ;
44944 bool temp2 = false ;
44945 PyObject * obj0 = 0 ;
44946 PyObject * obj1 = 0 ;
44947 char * kwnames[] = {
44948 (char *) "self",(char *) "strings", NULL
44949 };
44950
44951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44953 if (!SWIG_IsOK(res1)) {
44954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44955 }
44956 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44957 {
44958 if (! PySequence_Check(obj1)) {
44959 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44960 SWIG_fail;
44961 }
44962 arg2 = new wxArrayString;
44963 temp2 = true;
44964 int i, len=PySequence_Length(obj1);
44965 for (i=0; i<len; i++) {
44966 PyObject* item = PySequence_GetItem(obj1, i);
44967 wxString* s = wxString_in_helper(item);
44968 if (PyErr_Occurred()) SWIG_fail;
44969 arg2->Add(*s);
44970 delete s;
44971 Py_DECREF(item);
44972 }
44973 }
44974 {
44975 PyThreadState* __tstate = wxPyBeginAllowThreads();
44976 (arg1)->Append((wxArrayString const &)*arg2);
44977 wxPyEndAllowThreads(__tstate);
44978 if (PyErr_Occurred()) SWIG_fail;
44979 }
44980 resultobj = SWIG_Py_Void();
44981 {
44982 if (temp2) delete arg2;
44983 }
44984 return resultobj;
44985 fail:
44986 {
44987 if (temp2) delete arg2;
44988 }
44989 return NULL;
44990 }
44991
44992
44993 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44994 PyObject *resultobj = 0;
44995 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44996 wxString *arg2 = 0 ;
44997 unsigned int arg3 ;
44998 PyObject *arg4 = (PyObject *) NULL ;
44999 int result;
45000 void *argp1 = 0 ;
45001 int res1 = 0 ;
45002 bool temp2 = false ;
45003 unsigned int val3 ;
45004 int ecode3 = 0 ;
45005 PyObject * obj0 = 0 ;
45006 PyObject * obj1 = 0 ;
45007 PyObject * obj2 = 0 ;
45008 PyObject * obj3 = 0 ;
45009 char * kwnames[] = {
45010 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45011 };
45012
45013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45015 if (!SWIG_IsOK(res1)) {
45016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45017 }
45018 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45019 {
45020 arg2 = wxString_in_helper(obj1);
45021 if (arg2 == NULL) SWIG_fail;
45022 temp2 = true;
45023 }
45024 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45025 if (!SWIG_IsOK(ecode3)) {
45026 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45027 }
45028 arg3 = static_cast< unsigned int >(val3);
45029 if (obj3) {
45030 arg4 = obj3;
45031 }
45032 {
45033 PyThreadState* __tstate = wxPyBeginAllowThreads();
45034 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45035 wxPyEndAllowThreads(__tstate);
45036 if (PyErr_Occurred()) SWIG_fail;
45037 }
45038 resultobj = SWIG_From_int(static_cast< int >(result));
45039 {
45040 if (temp2)
45041 delete arg2;
45042 }
45043 return resultobj;
45044 fail:
45045 {
45046 if (temp2)
45047 delete arg2;
45048 }
45049 return NULL;
45050 }
45051
45052
45053 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45054 PyObject *resultobj = 0;
45055 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45056 void *argp1 = 0 ;
45057 int res1 = 0 ;
45058 PyObject *swig_obj[1] ;
45059
45060 if (!args) SWIG_fail;
45061 swig_obj[0] = args;
45062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45063 if (!SWIG_IsOK(res1)) {
45064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45065 }
45066 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45067 {
45068 PyThreadState* __tstate = wxPyBeginAllowThreads();
45069 (arg1)->Clear();
45070 wxPyEndAllowThreads(__tstate);
45071 if (PyErr_Occurred()) SWIG_fail;
45072 }
45073 resultobj = SWIG_Py_Void();
45074 return resultobj;
45075 fail:
45076 return NULL;
45077 }
45078
45079
45080 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45081 PyObject *resultobj = 0;
45082 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45083 unsigned int arg2 ;
45084 void *argp1 = 0 ;
45085 int res1 = 0 ;
45086 unsigned int val2 ;
45087 int ecode2 = 0 ;
45088 PyObject * obj0 = 0 ;
45089 PyObject * obj1 = 0 ;
45090 char * kwnames[] = {
45091 (char *) "self",(char *) "n", NULL
45092 };
45093
45094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45096 if (!SWIG_IsOK(res1)) {
45097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45098 }
45099 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45100 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45101 if (!SWIG_IsOK(ecode2)) {
45102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45103 }
45104 arg2 = static_cast< unsigned int >(val2);
45105 {
45106 PyThreadState* __tstate = wxPyBeginAllowThreads();
45107 (arg1)->Delete(arg2);
45108 wxPyEndAllowThreads(__tstate);
45109 if (PyErr_Occurred()) SWIG_fail;
45110 }
45111 resultobj = SWIG_Py_Void();
45112 return resultobj;
45113 fail:
45114 return NULL;
45115 }
45116
45117
45118 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45119 PyObject *resultobj = 0;
45120 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45121 unsigned int arg2 ;
45122 PyObject *result = 0 ;
45123 void *argp1 = 0 ;
45124 int res1 = 0 ;
45125 unsigned int val2 ;
45126 int ecode2 = 0 ;
45127 PyObject * obj0 = 0 ;
45128 PyObject * obj1 = 0 ;
45129 char * kwnames[] = {
45130 (char *) "self",(char *) "n", NULL
45131 };
45132
45133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45135 if (!SWIG_IsOK(res1)) {
45136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45137 }
45138 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45139 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45140 if (!SWIG_IsOK(ecode2)) {
45141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45142 }
45143 arg2 = static_cast< unsigned int >(val2);
45144 {
45145 PyThreadState* __tstate = wxPyBeginAllowThreads();
45146 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45147 wxPyEndAllowThreads(__tstate);
45148 if (PyErr_Occurred()) SWIG_fail;
45149 }
45150 resultobj = result;
45151 return resultobj;
45152 fail:
45153 return NULL;
45154 }
45155
45156
45157 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45158 PyObject *resultobj = 0;
45159 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45160 unsigned int arg2 ;
45161 PyObject *arg3 = (PyObject *) 0 ;
45162 void *argp1 = 0 ;
45163 int res1 = 0 ;
45164 unsigned int val2 ;
45165 int ecode2 = 0 ;
45166 PyObject * obj0 = 0 ;
45167 PyObject * obj1 = 0 ;
45168 PyObject * obj2 = 0 ;
45169 char * kwnames[] = {
45170 (char *) "self",(char *) "n",(char *) "clientData", NULL
45171 };
45172
45173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45175 if (!SWIG_IsOK(res1)) {
45176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45177 }
45178 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45179 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45180 if (!SWIG_IsOK(ecode2)) {
45181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45182 }
45183 arg2 = static_cast< unsigned int >(val2);
45184 arg3 = obj2;
45185 {
45186 PyThreadState* __tstate = wxPyBeginAllowThreads();
45187 wxItemContainer_SetClientData(arg1,arg2,arg3);
45188 wxPyEndAllowThreads(__tstate);
45189 if (PyErr_Occurred()) SWIG_fail;
45190 }
45191 resultobj = SWIG_Py_Void();
45192 return resultobj;
45193 fail:
45194 return NULL;
45195 }
45196
45197
45198 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45199 PyObject *resultobj = 0;
45200 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45201 unsigned int result;
45202 void *argp1 = 0 ;
45203 int res1 = 0 ;
45204 PyObject *swig_obj[1] ;
45205
45206 if (!args) SWIG_fail;
45207 swig_obj[0] = args;
45208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45209 if (!SWIG_IsOK(res1)) {
45210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45211 }
45212 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45213 {
45214 PyThreadState* __tstate = wxPyBeginAllowThreads();
45215 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45216 wxPyEndAllowThreads(__tstate);
45217 if (PyErr_Occurred()) SWIG_fail;
45218 }
45219 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45220 return resultobj;
45221 fail:
45222 return NULL;
45223 }
45224
45225
45226 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45227 PyObject *resultobj = 0;
45228 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45229 bool result;
45230 void *argp1 = 0 ;
45231 int res1 = 0 ;
45232 PyObject *swig_obj[1] ;
45233
45234 if (!args) SWIG_fail;
45235 swig_obj[0] = args;
45236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45237 if (!SWIG_IsOK(res1)) {
45238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45239 }
45240 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45241 {
45242 PyThreadState* __tstate = wxPyBeginAllowThreads();
45243 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45244 wxPyEndAllowThreads(__tstate);
45245 if (PyErr_Occurred()) SWIG_fail;
45246 }
45247 {
45248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45249 }
45250 return resultobj;
45251 fail:
45252 return NULL;
45253 }
45254
45255
45256 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45257 PyObject *resultobj = 0;
45258 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45259 unsigned int arg2 ;
45260 wxString result;
45261 void *argp1 = 0 ;
45262 int res1 = 0 ;
45263 unsigned int val2 ;
45264 int ecode2 = 0 ;
45265 PyObject * obj0 = 0 ;
45266 PyObject * obj1 = 0 ;
45267 char * kwnames[] = {
45268 (char *) "self",(char *) "n", NULL
45269 };
45270
45271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45273 if (!SWIG_IsOK(res1)) {
45274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45275 }
45276 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45277 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45278 if (!SWIG_IsOK(ecode2)) {
45279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45280 }
45281 arg2 = static_cast< unsigned int >(val2);
45282 {
45283 PyThreadState* __tstate = wxPyBeginAllowThreads();
45284 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45285 wxPyEndAllowThreads(__tstate);
45286 if (PyErr_Occurred()) SWIG_fail;
45287 }
45288 {
45289 #if wxUSE_UNICODE
45290 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45291 #else
45292 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45293 #endif
45294 }
45295 return resultobj;
45296 fail:
45297 return NULL;
45298 }
45299
45300
45301 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45302 PyObject *resultobj = 0;
45303 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45304 wxArrayString result;
45305 void *argp1 = 0 ;
45306 int res1 = 0 ;
45307 PyObject *swig_obj[1] ;
45308
45309 if (!args) SWIG_fail;
45310 swig_obj[0] = args;
45311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45312 if (!SWIG_IsOK(res1)) {
45313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45314 }
45315 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45316 {
45317 PyThreadState* __tstate = wxPyBeginAllowThreads();
45318 result = ((wxItemContainer const *)arg1)->GetStrings();
45319 wxPyEndAllowThreads(__tstate);
45320 if (PyErr_Occurred()) SWIG_fail;
45321 }
45322 {
45323 resultobj = wxArrayString2PyList_helper(result);
45324 }
45325 return resultobj;
45326 fail:
45327 return NULL;
45328 }
45329
45330
45331 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45332 PyObject *resultobj = 0;
45333 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45334 unsigned int arg2 ;
45335 wxString *arg3 = 0 ;
45336 void *argp1 = 0 ;
45337 int res1 = 0 ;
45338 unsigned int val2 ;
45339 int ecode2 = 0 ;
45340 bool temp3 = false ;
45341 PyObject * obj0 = 0 ;
45342 PyObject * obj1 = 0 ;
45343 PyObject * obj2 = 0 ;
45344 char * kwnames[] = {
45345 (char *) "self",(char *) "n",(char *) "s", NULL
45346 };
45347
45348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45350 if (!SWIG_IsOK(res1)) {
45351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45352 }
45353 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45354 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45355 if (!SWIG_IsOK(ecode2)) {
45356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45357 }
45358 arg2 = static_cast< unsigned int >(val2);
45359 {
45360 arg3 = wxString_in_helper(obj2);
45361 if (arg3 == NULL) SWIG_fail;
45362 temp3 = true;
45363 }
45364 {
45365 PyThreadState* __tstate = wxPyBeginAllowThreads();
45366 (arg1)->SetString(arg2,(wxString const &)*arg3);
45367 wxPyEndAllowThreads(__tstate);
45368 if (PyErr_Occurred()) SWIG_fail;
45369 }
45370 resultobj = SWIG_Py_Void();
45371 {
45372 if (temp3)
45373 delete arg3;
45374 }
45375 return resultobj;
45376 fail:
45377 {
45378 if (temp3)
45379 delete arg3;
45380 }
45381 return NULL;
45382 }
45383
45384
45385 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45386 PyObject *resultobj = 0;
45387 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45388 wxString *arg2 = 0 ;
45389 int result;
45390 void *argp1 = 0 ;
45391 int res1 = 0 ;
45392 bool temp2 = false ;
45393 PyObject * obj0 = 0 ;
45394 PyObject * obj1 = 0 ;
45395 char * kwnames[] = {
45396 (char *) "self",(char *) "s", NULL
45397 };
45398
45399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45401 if (!SWIG_IsOK(res1)) {
45402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45403 }
45404 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45405 {
45406 arg2 = wxString_in_helper(obj1);
45407 if (arg2 == NULL) SWIG_fail;
45408 temp2 = true;
45409 }
45410 {
45411 PyThreadState* __tstate = wxPyBeginAllowThreads();
45412 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45413 wxPyEndAllowThreads(__tstate);
45414 if (PyErr_Occurred()) SWIG_fail;
45415 }
45416 resultobj = SWIG_From_int(static_cast< int >(result));
45417 {
45418 if (temp2)
45419 delete arg2;
45420 }
45421 return resultobj;
45422 fail:
45423 {
45424 if (temp2)
45425 delete arg2;
45426 }
45427 return NULL;
45428 }
45429
45430
45431 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45432 PyObject *resultobj = 0;
45433 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45434 int arg2 ;
45435 void *argp1 = 0 ;
45436 int res1 = 0 ;
45437 int val2 ;
45438 int ecode2 = 0 ;
45439 PyObject * obj0 = 0 ;
45440 PyObject * obj1 = 0 ;
45441 char * kwnames[] = {
45442 (char *) "self",(char *) "n", NULL
45443 };
45444
45445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45447 if (!SWIG_IsOK(res1)) {
45448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45449 }
45450 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45451 ecode2 = SWIG_AsVal_int(obj1, &val2);
45452 if (!SWIG_IsOK(ecode2)) {
45453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45454 }
45455 arg2 = static_cast< int >(val2);
45456 {
45457 PyThreadState* __tstate = wxPyBeginAllowThreads();
45458 (arg1)->SetSelection(arg2);
45459 wxPyEndAllowThreads(__tstate);
45460 if (PyErr_Occurred()) SWIG_fail;
45461 }
45462 resultobj = SWIG_Py_Void();
45463 return resultobj;
45464 fail:
45465 return NULL;
45466 }
45467
45468
45469 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45470 PyObject *resultobj = 0;
45471 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45472 int result;
45473 void *argp1 = 0 ;
45474 int res1 = 0 ;
45475 PyObject *swig_obj[1] ;
45476
45477 if (!args) SWIG_fail;
45478 swig_obj[0] = args;
45479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45480 if (!SWIG_IsOK(res1)) {
45481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45482 }
45483 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45484 {
45485 PyThreadState* __tstate = wxPyBeginAllowThreads();
45486 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45487 wxPyEndAllowThreads(__tstate);
45488 if (PyErr_Occurred()) SWIG_fail;
45489 }
45490 resultobj = SWIG_From_int(static_cast< int >(result));
45491 return resultobj;
45492 fail:
45493 return NULL;
45494 }
45495
45496
45497 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45498 PyObject *resultobj = 0;
45499 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45500 wxString *arg2 = 0 ;
45501 bool result;
45502 void *argp1 = 0 ;
45503 int res1 = 0 ;
45504 bool temp2 = false ;
45505 PyObject * obj0 = 0 ;
45506 PyObject * obj1 = 0 ;
45507 char * kwnames[] = {
45508 (char *) "self",(char *) "s", NULL
45509 };
45510
45511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45513 if (!SWIG_IsOK(res1)) {
45514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45515 }
45516 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45517 {
45518 arg2 = wxString_in_helper(obj1);
45519 if (arg2 == NULL) SWIG_fail;
45520 temp2 = true;
45521 }
45522 {
45523 PyThreadState* __tstate = wxPyBeginAllowThreads();
45524 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45525 wxPyEndAllowThreads(__tstate);
45526 if (PyErr_Occurred()) SWIG_fail;
45527 }
45528 {
45529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45530 }
45531 {
45532 if (temp2)
45533 delete arg2;
45534 }
45535 return resultobj;
45536 fail:
45537 {
45538 if (temp2)
45539 delete arg2;
45540 }
45541 return NULL;
45542 }
45543
45544
45545 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45546 PyObject *resultobj = 0;
45547 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45548 wxString 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_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45558 }
45559 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45560 {
45561 PyThreadState* __tstate = wxPyBeginAllowThreads();
45562 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45563 wxPyEndAllowThreads(__tstate);
45564 if (PyErr_Occurred()) SWIG_fail;
45565 }
45566 {
45567 #if wxUSE_UNICODE
45568 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45569 #else
45570 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45571 #endif
45572 }
45573 return resultobj;
45574 fail:
45575 return NULL;
45576 }
45577
45578
45579 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45580 PyObject *resultobj = 0;
45581 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45582 int arg2 ;
45583 void *argp1 = 0 ;
45584 int res1 = 0 ;
45585 int val2 ;
45586 int ecode2 = 0 ;
45587 PyObject * obj0 = 0 ;
45588 PyObject * obj1 = 0 ;
45589 char * kwnames[] = {
45590 (char *) "self",(char *) "n", NULL
45591 };
45592
45593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45595 if (!SWIG_IsOK(res1)) {
45596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45597 }
45598 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45599 ecode2 = SWIG_AsVal_int(obj1, &val2);
45600 if (!SWIG_IsOK(ecode2)) {
45601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45602 }
45603 arg2 = static_cast< int >(val2);
45604 {
45605 PyThreadState* __tstate = wxPyBeginAllowThreads();
45606 (arg1)->Select(arg2);
45607 wxPyEndAllowThreads(__tstate);
45608 if (PyErr_Occurred()) SWIG_fail;
45609 }
45610 resultobj = SWIG_Py_Void();
45611 return resultobj;
45612 fail:
45613 return NULL;
45614 }
45615
45616
45617 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45618 PyObject *obj;
45619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45620 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45621 return SWIG_Py_Void();
45622 }
45623
45624 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45625 PyObject *obj;
45626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45627 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45628 return SWIG_Py_Void();
45629 }
45630
45631 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45632 PyObject *resultobj = 0;
45633 wxSizerItem *result = 0 ;
45634
45635 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45636 {
45637 PyThreadState* __tstate = wxPyBeginAllowThreads();
45638 result = (wxSizerItem *)new wxSizerItem();
45639 wxPyEndAllowThreads(__tstate);
45640 if (PyErr_Occurred()) SWIG_fail;
45641 }
45642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45643 return resultobj;
45644 fail:
45645 return NULL;
45646 }
45647
45648
45649 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45650 PyObject *resultobj = 0;
45651 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45652 void *argp1 = 0 ;
45653 int res1 = 0 ;
45654 PyObject *swig_obj[1] ;
45655
45656 if (!args) SWIG_fail;
45657 swig_obj[0] = args;
45658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45659 if (!SWIG_IsOK(res1)) {
45660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45661 }
45662 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45663 {
45664 PyThreadState* __tstate = wxPyBeginAllowThreads();
45665 delete arg1;
45666
45667 wxPyEndAllowThreads(__tstate);
45668 if (PyErr_Occurred()) SWIG_fail;
45669 }
45670 resultobj = SWIG_Py_Void();
45671 return resultobj;
45672 fail:
45673 return NULL;
45674 }
45675
45676
45677 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45678 PyObject *resultobj = 0;
45679 wxWindow *arg1 = (wxWindow *) 0 ;
45680 int arg2 ;
45681 int arg3 ;
45682 int arg4 ;
45683 PyObject *arg5 = (PyObject *) NULL ;
45684 wxSizerItem *result = 0 ;
45685 void *argp1 = 0 ;
45686 int res1 = 0 ;
45687 int val2 ;
45688 int ecode2 = 0 ;
45689 int val3 ;
45690 int ecode3 = 0 ;
45691 int val4 ;
45692 int ecode4 = 0 ;
45693 PyObject * obj0 = 0 ;
45694 PyObject * obj1 = 0 ;
45695 PyObject * obj2 = 0 ;
45696 PyObject * obj3 = 0 ;
45697 PyObject * obj4 = 0 ;
45698 char * kwnames[] = {
45699 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45700 };
45701
45702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45704 if (!SWIG_IsOK(res1)) {
45705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45706 }
45707 arg1 = reinterpret_cast< wxWindow * >(argp1);
45708 ecode2 = SWIG_AsVal_int(obj1, &val2);
45709 if (!SWIG_IsOK(ecode2)) {
45710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45711 }
45712 arg2 = static_cast< int >(val2);
45713 ecode3 = SWIG_AsVal_int(obj2, &val3);
45714 if (!SWIG_IsOK(ecode3)) {
45715 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45716 }
45717 arg3 = static_cast< int >(val3);
45718 ecode4 = SWIG_AsVal_int(obj3, &val4);
45719 if (!SWIG_IsOK(ecode4)) {
45720 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45721 }
45722 arg4 = static_cast< int >(val4);
45723 if (obj4) {
45724 arg5 = obj4;
45725 }
45726 {
45727 PyThreadState* __tstate = wxPyBeginAllowThreads();
45728 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45729 wxPyEndAllowThreads(__tstate);
45730 if (PyErr_Occurred()) SWIG_fail;
45731 }
45732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45733 return resultobj;
45734 fail:
45735 return NULL;
45736 }
45737
45738
45739 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45740 PyObject *resultobj = 0;
45741 int arg1 ;
45742 int arg2 ;
45743 int arg3 ;
45744 int arg4 ;
45745 int arg5 ;
45746 PyObject *arg6 = (PyObject *) NULL ;
45747 wxSizerItem *result = 0 ;
45748 int val1 ;
45749 int ecode1 = 0 ;
45750 int val2 ;
45751 int ecode2 = 0 ;
45752 int val3 ;
45753 int ecode3 = 0 ;
45754 int val4 ;
45755 int ecode4 = 0 ;
45756 int val5 ;
45757 int ecode5 = 0 ;
45758 PyObject * obj0 = 0 ;
45759 PyObject * obj1 = 0 ;
45760 PyObject * obj2 = 0 ;
45761 PyObject * obj3 = 0 ;
45762 PyObject * obj4 = 0 ;
45763 PyObject * obj5 = 0 ;
45764 char * kwnames[] = {
45765 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45766 };
45767
45768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45769 ecode1 = SWIG_AsVal_int(obj0, &val1);
45770 if (!SWIG_IsOK(ecode1)) {
45771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45772 }
45773 arg1 = static_cast< int >(val1);
45774 ecode2 = SWIG_AsVal_int(obj1, &val2);
45775 if (!SWIG_IsOK(ecode2)) {
45776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45777 }
45778 arg2 = static_cast< int >(val2);
45779 ecode3 = SWIG_AsVal_int(obj2, &val3);
45780 if (!SWIG_IsOK(ecode3)) {
45781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45782 }
45783 arg3 = static_cast< int >(val3);
45784 ecode4 = SWIG_AsVal_int(obj3, &val4);
45785 if (!SWIG_IsOK(ecode4)) {
45786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45787 }
45788 arg4 = static_cast< int >(val4);
45789 ecode5 = SWIG_AsVal_int(obj4, &val5);
45790 if (!SWIG_IsOK(ecode5)) {
45791 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45792 }
45793 arg5 = static_cast< int >(val5);
45794 if (obj5) {
45795 arg6 = obj5;
45796 }
45797 {
45798 PyThreadState* __tstate = wxPyBeginAllowThreads();
45799 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45800 wxPyEndAllowThreads(__tstate);
45801 if (PyErr_Occurred()) SWIG_fail;
45802 }
45803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45804 return resultobj;
45805 fail:
45806 return NULL;
45807 }
45808
45809
45810 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45811 PyObject *resultobj = 0;
45812 wxSizer *arg1 = (wxSizer *) 0 ;
45813 int arg2 ;
45814 int arg3 ;
45815 int arg4 ;
45816 PyObject *arg5 = (PyObject *) NULL ;
45817 wxSizerItem *result = 0 ;
45818 int res1 = 0 ;
45819 int val2 ;
45820 int ecode2 = 0 ;
45821 int val3 ;
45822 int ecode3 = 0 ;
45823 int val4 ;
45824 int ecode4 = 0 ;
45825 PyObject * obj0 = 0 ;
45826 PyObject * obj1 = 0 ;
45827 PyObject * obj2 = 0 ;
45828 PyObject * obj3 = 0 ;
45829 PyObject * obj4 = 0 ;
45830 char * kwnames[] = {
45831 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45832 };
45833
45834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45835 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45836 if (!SWIG_IsOK(res1)) {
45837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45838 }
45839 ecode2 = SWIG_AsVal_int(obj1, &val2);
45840 if (!SWIG_IsOK(ecode2)) {
45841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45842 }
45843 arg2 = static_cast< int >(val2);
45844 ecode3 = SWIG_AsVal_int(obj2, &val3);
45845 if (!SWIG_IsOK(ecode3)) {
45846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45847 }
45848 arg3 = static_cast< int >(val3);
45849 ecode4 = SWIG_AsVal_int(obj3, &val4);
45850 if (!SWIG_IsOK(ecode4)) {
45851 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45852 }
45853 arg4 = static_cast< int >(val4);
45854 if (obj4) {
45855 arg5 = obj4;
45856 }
45857 {
45858 PyThreadState* __tstate = wxPyBeginAllowThreads();
45859 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45860 wxPyEndAllowThreads(__tstate);
45861 if (PyErr_Occurred()) SWIG_fail;
45862 }
45863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45864 return resultobj;
45865 fail:
45866 return NULL;
45867 }
45868
45869
45870 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45871 PyObject *resultobj = 0;
45872 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45873 void *argp1 = 0 ;
45874 int res1 = 0 ;
45875 PyObject *swig_obj[1] ;
45876
45877 if (!args) SWIG_fail;
45878 swig_obj[0] = args;
45879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45880 if (!SWIG_IsOK(res1)) {
45881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45882 }
45883 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45884 {
45885 PyThreadState* __tstate = wxPyBeginAllowThreads();
45886 (arg1)->DeleteWindows();
45887 wxPyEndAllowThreads(__tstate);
45888 if (PyErr_Occurred()) SWIG_fail;
45889 }
45890 resultobj = SWIG_Py_Void();
45891 return resultobj;
45892 fail:
45893 return NULL;
45894 }
45895
45896
45897 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45898 PyObject *resultobj = 0;
45899 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45900 void *argp1 = 0 ;
45901 int res1 = 0 ;
45902 PyObject *swig_obj[1] ;
45903
45904 if (!args) SWIG_fail;
45905 swig_obj[0] = args;
45906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45907 if (!SWIG_IsOK(res1)) {
45908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45909 }
45910 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45911 {
45912 PyThreadState* __tstate = wxPyBeginAllowThreads();
45913 (arg1)->DetachSizer();
45914 wxPyEndAllowThreads(__tstate);
45915 if (PyErr_Occurred()) SWIG_fail;
45916 }
45917 resultobj = SWIG_Py_Void();
45918 return resultobj;
45919 fail:
45920 return NULL;
45921 }
45922
45923
45924 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45925 PyObject *resultobj = 0;
45926 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45927 wxSize result;
45928 void *argp1 = 0 ;
45929 int res1 = 0 ;
45930 PyObject *swig_obj[1] ;
45931
45932 if (!args) SWIG_fail;
45933 swig_obj[0] = args;
45934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45935 if (!SWIG_IsOK(res1)) {
45936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45937 }
45938 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45939 {
45940 PyThreadState* __tstate = wxPyBeginAllowThreads();
45941 result = (arg1)->GetSize();
45942 wxPyEndAllowThreads(__tstate);
45943 if (PyErr_Occurred()) SWIG_fail;
45944 }
45945 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45946 return resultobj;
45947 fail:
45948 return NULL;
45949 }
45950
45951
45952 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45953 PyObject *resultobj = 0;
45954 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45955 wxSize result;
45956 void *argp1 = 0 ;
45957 int res1 = 0 ;
45958 PyObject *swig_obj[1] ;
45959
45960 if (!args) SWIG_fail;
45961 swig_obj[0] = args;
45962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45963 if (!SWIG_IsOK(res1)) {
45964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45965 }
45966 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45967 {
45968 PyThreadState* __tstate = wxPyBeginAllowThreads();
45969 result = (arg1)->CalcMin();
45970 wxPyEndAllowThreads(__tstate);
45971 if (PyErr_Occurred()) SWIG_fail;
45972 }
45973 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45974 return resultobj;
45975 fail:
45976 return NULL;
45977 }
45978
45979
45980 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45981 PyObject *resultobj = 0;
45982 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45983 wxPoint *arg2 = 0 ;
45984 wxSize *arg3 = 0 ;
45985 void *argp1 = 0 ;
45986 int res1 = 0 ;
45987 wxPoint temp2 ;
45988 wxSize temp3 ;
45989 PyObject * obj0 = 0 ;
45990 PyObject * obj1 = 0 ;
45991 PyObject * obj2 = 0 ;
45992 char * kwnames[] = {
45993 (char *) "self",(char *) "pos",(char *) "size", NULL
45994 };
45995
45996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45998 if (!SWIG_IsOK(res1)) {
45999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46000 }
46001 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46002 {
46003 arg2 = &temp2;
46004 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46005 }
46006 {
46007 arg3 = &temp3;
46008 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46009 }
46010 {
46011 PyThreadState* __tstate = wxPyBeginAllowThreads();
46012 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46013 wxPyEndAllowThreads(__tstate);
46014 if (PyErr_Occurred()) SWIG_fail;
46015 }
46016 resultobj = SWIG_Py_Void();
46017 return resultobj;
46018 fail:
46019 return NULL;
46020 }
46021
46022
46023 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46024 PyObject *resultobj = 0;
46025 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46026 wxSize result;
46027 void *argp1 = 0 ;
46028 int res1 = 0 ;
46029 PyObject *swig_obj[1] ;
46030
46031 if (!args) SWIG_fail;
46032 swig_obj[0] = args;
46033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46034 if (!SWIG_IsOK(res1)) {
46035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46036 }
46037 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46038 {
46039 PyThreadState* __tstate = wxPyBeginAllowThreads();
46040 result = (arg1)->GetMinSize();
46041 wxPyEndAllowThreads(__tstate);
46042 if (PyErr_Occurred()) SWIG_fail;
46043 }
46044 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46045 return resultobj;
46046 fail:
46047 return NULL;
46048 }
46049
46050
46051 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46052 PyObject *resultobj = 0;
46053 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46054 wxSize result;
46055 void *argp1 = 0 ;
46056 int res1 = 0 ;
46057 PyObject *swig_obj[1] ;
46058
46059 if (!args) SWIG_fail;
46060 swig_obj[0] = args;
46061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46062 if (!SWIG_IsOK(res1)) {
46063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46064 }
46065 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46066 {
46067 PyThreadState* __tstate = wxPyBeginAllowThreads();
46068 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46069 wxPyEndAllowThreads(__tstate);
46070 if (PyErr_Occurred()) SWIG_fail;
46071 }
46072 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46073 return resultobj;
46074 fail:
46075 return NULL;
46076 }
46077
46078
46079 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46080 PyObject *resultobj = 0;
46081 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46082 int arg2 ;
46083 int arg3 ;
46084 void *argp1 = 0 ;
46085 int res1 = 0 ;
46086 int val2 ;
46087 int ecode2 = 0 ;
46088 int val3 ;
46089 int ecode3 = 0 ;
46090 PyObject * obj0 = 0 ;
46091 PyObject * obj1 = 0 ;
46092 PyObject * obj2 = 0 ;
46093 char * kwnames[] = {
46094 (char *) "self",(char *) "x",(char *) "y", NULL
46095 };
46096
46097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46099 if (!SWIG_IsOK(res1)) {
46100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46101 }
46102 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46103 ecode2 = SWIG_AsVal_int(obj1, &val2);
46104 if (!SWIG_IsOK(ecode2)) {
46105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46106 }
46107 arg2 = static_cast< int >(val2);
46108 ecode3 = SWIG_AsVal_int(obj2, &val3);
46109 if (!SWIG_IsOK(ecode3)) {
46110 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46111 }
46112 arg3 = static_cast< int >(val3);
46113 {
46114 PyThreadState* __tstate = wxPyBeginAllowThreads();
46115 (arg1)->SetInitSize(arg2,arg3);
46116 wxPyEndAllowThreads(__tstate);
46117 if (PyErr_Occurred()) SWIG_fail;
46118 }
46119 resultobj = SWIG_Py_Void();
46120 return resultobj;
46121 fail:
46122 return NULL;
46123 }
46124
46125
46126 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46127 PyObject *resultobj = 0;
46128 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46129 int arg2 ;
46130 int arg3 ;
46131 void *argp1 = 0 ;
46132 int res1 = 0 ;
46133 int val2 ;
46134 int ecode2 = 0 ;
46135 int val3 ;
46136 int ecode3 = 0 ;
46137 PyObject * obj0 = 0 ;
46138 PyObject * obj1 = 0 ;
46139 PyObject * obj2 = 0 ;
46140 char * kwnames[] = {
46141 (char *) "self",(char *) "width",(char *) "height", NULL
46142 };
46143
46144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46146 if (!SWIG_IsOK(res1)) {
46147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46148 }
46149 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46150 ecode2 = SWIG_AsVal_int(obj1, &val2);
46151 if (!SWIG_IsOK(ecode2)) {
46152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46153 }
46154 arg2 = static_cast< int >(val2);
46155 ecode3 = SWIG_AsVal_int(obj2, &val3);
46156 if (!SWIG_IsOK(ecode3)) {
46157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46158 }
46159 arg3 = static_cast< int >(val3);
46160 {
46161 PyThreadState* __tstate = wxPyBeginAllowThreads();
46162 (arg1)->SetRatio(arg2,arg3);
46163 wxPyEndAllowThreads(__tstate);
46164 if (PyErr_Occurred()) SWIG_fail;
46165 }
46166 resultobj = SWIG_Py_Void();
46167 return resultobj;
46168 fail:
46169 return NULL;
46170 }
46171
46172
46173 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46174 PyObject *resultobj = 0;
46175 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46176 wxSize *arg2 = 0 ;
46177 void *argp1 = 0 ;
46178 int res1 = 0 ;
46179 wxSize temp2 ;
46180 PyObject * obj0 = 0 ;
46181 PyObject * obj1 = 0 ;
46182 char * kwnames[] = {
46183 (char *) "self",(char *) "size", NULL
46184 };
46185
46186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46188 if (!SWIG_IsOK(res1)) {
46189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46190 }
46191 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46192 {
46193 arg2 = &temp2;
46194 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46195 }
46196 {
46197 PyThreadState* __tstate = wxPyBeginAllowThreads();
46198 (arg1)->SetRatio((wxSize const &)*arg2);
46199 wxPyEndAllowThreads(__tstate);
46200 if (PyErr_Occurred()) SWIG_fail;
46201 }
46202 resultobj = SWIG_Py_Void();
46203 return resultobj;
46204 fail:
46205 return NULL;
46206 }
46207
46208
46209 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46210 PyObject *resultobj = 0;
46211 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46212 float arg2 ;
46213 void *argp1 = 0 ;
46214 int res1 = 0 ;
46215 float val2 ;
46216 int ecode2 = 0 ;
46217 PyObject * obj0 = 0 ;
46218 PyObject * obj1 = 0 ;
46219 char * kwnames[] = {
46220 (char *) "self",(char *) "ratio", NULL
46221 };
46222
46223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46225 if (!SWIG_IsOK(res1)) {
46226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46227 }
46228 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46229 ecode2 = SWIG_AsVal_float(obj1, &val2);
46230 if (!SWIG_IsOK(ecode2)) {
46231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46232 }
46233 arg2 = static_cast< float >(val2);
46234 {
46235 PyThreadState* __tstate = wxPyBeginAllowThreads();
46236 (arg1)->SetRatio(arg2);
46237 wxPyEndAllowThreads(__tstate);
46238 if (PyErr_Occurred()) SWIG_fail;
46239 }
46240 resultobj = SWIG_Py_Void();
46241 return resultobj;
46242 fail:
46243 return NULL;
46244 }
46245
46246
46247 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46248 PyObject *resultobj = 0;
46249 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46250 float result;
46251 void *argp1 = 0 ;
46252 int res1 = 0 ;
46253 PyObject *swig_obj[1] ;
46254
46255 if (!args) SWIG_fail;
46256 swig_obj[0] = args;
46257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46258 if (!SWIG_IsOK(res1)) {
46259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46260 }
46261 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46262 {
46263 PyThreadState* __tstate = wxPyBeginAllowThreads();
46264 result = (float)(arg1)->GetRatio();
46265 wxPyEndAllowThreads(__tstate);
46266 if (PyErr_Occurred()) SWIG_fail;
46267 }
46268 resultobj = SWIG_From_float(static_cast< float >(result));
46269 return resultobj;
46270 fail:
46271 return NULL;
46272 }
46273
46274
46275 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46276 PyObject *resultobj = 0;
46277 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46278 wxRect result;
46279 void *argp1 = 0 ;
46280 int res1 = 0 ;
46281 PyObject *swig_obj[1] ;
46282
46283 if (!args) SWIG_fail;
46284 swig_obj[0] = args;
46285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46286 if (!SWIG_IsOK(res1)) {
46287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46288 }
46289 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46290 {
46291 PyThreadState* __tstate = wxPyBeginAllowThreads();
46292 result = (arg1)->GetRect();
46293 wxPyEndAllowThreads(__tstate);
46294 if (PyErr_Occurred()) SWIG_fail;
46295 }
46296 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46297 return resultobj;
46298 fail:
46299 return NULL;
46300 }
46301
46302
46303 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46304 PyObject *resultobj = 0;
46305 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46306 bool result;
46307 void *argp1 = 0 ;
46308 int res1 = 0 ;
46309 PyObject *swig_obj[1] ;
46310
46311 if (!args) SWIG_fail;
46312 swig_obj[0] = args;
46313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46314 if (!SWIG_IsOK(res1)) {
46315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46316 }
46317 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46318 {
46319 PyThreadState* __tstate = wxPyBeginAllowThreads();
46320 result = (bool)(arg1)->IsWindow();
46321 wxPyEndAllowThreads(__tstate);
46322 if (PyErr_Occurred()) SWIG_fail;
46323 }
46324 {
46325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46326 }
46327 return resultobj;
46328 fail:
46329 return NULL;
46330 }
46331
46332
46333 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46334 PyObject *resultobj = 0;
46335 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46336 bool result;
46337 void *argp1 = 0 ;
46338 int res1 = 0 ;
46339 PyObject *swig_obj[1] ;
46340
46341 if (!args) SWIG_fail;
46342 swig_obj[0] = args;
46343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46344 if (!SWIG_IsOK(res1)) {
46345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46346 }
46347 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46348 {
46349 PyThreadState* __tstate = wxPyBeginAllowThreads();
46350 result = (bool)(arg1)->IsSizer();
46351 wxPyEndAllowThreads(__tstate);
46352 if (PyErr_Occurred()) SWIG_fail;
46353 }
46354 {
46355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46356 }
46357 return resultobj;
46358 fail:
46359 return NULL;
46360 }
46361
46362
46363 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46364 PyObject *resultobj = 0;
46365 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46366 bool result;
46367 void *argp1 = 0 ;
46368 int res1 = 0 ;
46369 PyObject *swig_obj[1] ;
46370
46371 if (!args) SWIG_fail;
46372 swig_obj[0] = args;
46373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46374 if (!SWIG_IsOK(res1)) {
46375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46376 }
46377 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46378 {
46379 PyThreadState* __tstate = wxPyBeginAllowThreads();
46380 result = (bool)(arg1)->IsSpacer();
46381 wxPyEndAllowThreads(__tstate);
46382 if (PyErr_Occurred()) SWIG_fail;
46383 }
46384 {
46385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46386 }
46387 return resultobj;
46388 fail:
46389 return NULL;
46390 }
46391
46392
46393 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46394 PyObject *resultobj = 0;
46395 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46396 int arg2 ;
46397 void *argp1 = 0 ;
46398 int res1 = 0 ;
46399 int val2 ;
46400 int ecode2 = 0 ;
46401 PyObject * obj0 = 0 ;
46402 PyObject * obj1 = 0 ;
46403 char * kwnames[] = {
46404 (char *) "self",(char *) "proportion", NULL
46405 };
46406
46407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46409 if (!SWIG_IsOK(res1)) {
46410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46411 }
46412 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46413 ecode2 = SWIG_AsVal_int(obj1, &val2);
46414 if (!SWIG_IsOK(ecode2)) {
46415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46416 }
46417 arg2 = static_cast< int >(val2);
46418 {
46419 PyThreadState* __tstate = wxPyBeginAllowThreads();
46420 (arg1)->SetProportion(arg2);
46421 wxPyEndAllowThreads(__tstate);
46422 if (PyErr_Occurred()) SWIG_fail;
46423 }
46424 resultobj = SWIG_Py_Void();
46425 return resultobj;
46426 fail:
46427 return NULL;
46428 }
46429
46430
46431 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46432 PyObject *resultobj = 0;
46433 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46434 int result;
46435 void *argp1 = 0 ;
46436 int res1 = 0 ;
46437 PyObject *swig_obj[1] ;
46438
46439 if (!args) SWIG_fail;
46440 swig_obj[0] = args;
46441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46442 if (!SWIG_IsOK(res1)) {
46443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46444 }
46445 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46446 {
46447 PyThreadState* __tstate = wxPyBeginAllowThreads();
46448 result = (int)(arg1)->GetProportion();
46449 wxPyEndAllowThreads(__tstate);
46450 if (PyErr_Occurred()) SWIG_fail;
46451 }
46452 resultobj = SWIG_From_int(static_cast< int >(result));
46453 return resultobj;
46454 fail:
46455 return NULL;
46456 }
46457
46458
46459 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46460 PyObject *resultobj = 0;
46461 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46462 int arg2 ;
46463 void *argp1 = 0 ;
46464 int res1 = 0 ;
46465 int val2 ;
46466 int ecode2 = 0 ;
46467 PyObject * obj0 = 0 ;
46468 PyObject * obj1 = 0 ;
46469 char * kwnames[] = {
46470 (char *) "self",(char *) "flag", NULL
46471 };
46472
46473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46475 if (!SWIG_IsOK(res1)) {
46476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46477 }
46478 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46479 ecode2 = SWIG_AsVal_int(obj1, &val2);
46480 if (!SWIG_IsOK(ecode2)) {
46481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46482 }
46483 arg2 = static_cast< int >(val2);
46484 {
46485 PyThreadState* __tstate = wxPyBeginAllowThreads();
46486 (arg1)->SetFlag(arg2);
46487 wxPyEndAllowThreads(__tstate);
46488 if (PyErr_Occurred()) SWIG_fail;
46489 }
46490 resultobj = SWIG_Py_Void();
46491 return resultobj;
46492 fail:
46493 return NULL;
46494 }
46495
46496
46497 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46498 PyObject *resultobj = 0;
46499 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46500 int result;
46501 void *argp1 = 0 ;
46502 int res1 = 0 ;
46503 PyObject *swig_obj[1] ;
46504
46505 if (!args) SWIG_fail;
46506 swig_obj[0] = args;
46507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46508 if (!SWIG_IsOK(res1)) {
46509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46510 }
46511 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46512 {
46513 PyThreadState* __tstate = wxPyBeginAllowThreads();
46514 result = (int)(arg1)->GetFlag();
46515 wxPyEndAllowThreads(__tstate);
46516 if (PyErr_Occurred()) SWIG_fail;
46517 }
46518 resultobj = SWIG_From_int(static_cast< int >(result));
46519 return resultobj;
46520 fail:
46521 return NULL;
46522 }
46523
46524
46525 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46526 PyObject *resultobj = 0;
46527 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46528 int arg2 ;
46529 void *argp1 = 0 ;
46530 int res1 = 0 ;
46531 int val2 ;
46532 int ecode2 = 0 ;
46533 PyObject * obj0 = 0 ;
46534 PyObject * obj1 = 0 ;
46535 char * kwnames[] = {
46536 (char *) "self",(char *) "border", NULL
46537 };
46538
46539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46541 if (!SWIG_IsOK(res1)) {
46542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46543 }
46544 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46545 ecode2 = SWIG_AsVal_int(obj1, &val2);
46546 if (!SWIG_IsOK(ecode2)) {
46547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46548 }
46549 arg2 = static_cast< int >(val2);
46550 {
46551 PyThreadState* __tstate = wxPyBeginAllowThreads();
46552 (arg1)->SetBorder(arg2);
46553 wxPyEndAllowThreads(__tstate);
46554 if (PyErr_Occurred()) SWIG_fail;
46555 }
46556 resultobj = SWIG_Py_Void();
46557 return resultobj;
46558 fail:
46559 return NULL;
46560 }
46561
46562
46563 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46564 PyObject *resultobj = 0;
46565 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46566 int result;
46567 void *argp1 = 0 ;
46568 int res1 = 0 ;
46569 PyObject *swig_obj[1] ;
46570
46571 if (!args) SWIG_fail;
46572 swig_obj[0] = args;
46573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46574 if (!SWIG_IsOK(res1)) {
46575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46576 }
46577 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46578 {
46579 PyThreadState* __tstate = wxPyBeginAllowThreads();
46580 result = (int)(arg1)->GetBorder();
46581 wxPyEndAllowThreads(__tstate);
46582 if (PyErr_Occurred()) SWIG_fail;
46583 }
46584 resultobj = SWIG_From_int(static_cast< int >(result));
46585 return resultobj;
46586 fail:
46587 return NULL;
46588 }
46589
46590
46591 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46592 PyObject *resultobj = 0;
46593 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46594 wxWindow *result = 0 ;
46595 void *argp1 = 0 ;
46596 int res1 = 0 ;
46597 PyObject *swig_obj[1] ;
46598
46599 if (!args) SWIG_fail;
46600 swig_obj[0] = args;
46601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46602 if (!SWIG_IsOK(res1)) {
46603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46604 }
46605 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46606 {
46607 PyThreadState* __tstate = wxPyBeginAllowThreads();
46608 result = (wxWindow *)(arg1)->GetWindow();
46609 wxPyEndAllowThreads(__tstate);
46610 if (PyErr_Occurred()) SWIG_fail;
46611 }
46612 {
46613 resultobj = wxPyMake_wxObject(result, 0);
46614 }
46615 return resultobj;
46616 fail:
46617 return NULL;
46618 }
46619
46620
46621 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46622 PyObject *resultobj = 0;
46623 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46624 wxWindow *arg2 = (wxWindow *) 0 ;
46625 void *argp1 = 0 ;
46626 int res1 = 0 ;
46627 void *argp2 = 0 ;
46628 int res2 = 0 ;
46629 PyObject * obj0 = 0 ;
46630 PyObject * obj1 = 0 ;
46631 char * kwnames[] = {
46632 (char *) "self",(char *) "window", NULL
46633 };
46634
46635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46637 if (!SWIG_IsOK(res1)) {
46638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46639 }
46640 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46641 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46642 if (!SWIG_IsOK(res2)) {
46643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46644 }
46645 arg2 = reinterpret_cast< wxWindow * >(argp2);
46646 {
46647 PyThreadState* __tstate = wxPyBeginAllowThreads();
46648 (arg1)->SetWindow(arg2);
46649 wxPyEndAllowThreads(__tstate);
46650 if (PyErr_Occurred()) SWIG_fail;
46651 }
46652 resultobj = SWIG_Py_Void();
46653 return resultobj;
46654 fail:
46655 return NULL;
46656 }
46657
46658
46659 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46660 PyObject *resultobj = 0;
46661 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46662 wxSizer *result = 0 ;
46663 void *argp1 = 0 ;
46664 int res1 = 0 ;
46665 PyObject *swig_obj[1] ;
46666
46667 if (!args) SWIG_fail;
46668 swig_obj[0] = args;
46669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46670 if (!SWIG_IsOK(res1)) {
46671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46672 }
46673 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46674 {
46675 PyThreadState* __tstate = wxPyBeginAllowThreads();
46676 result = (wxSizer *)(arg1)->GetSizer();
46677 wxPyEndAllowThreads(__tstate);
46678 if (PyErr_Occurred()) SWIG_fail;
46679 }
46680 {
46681 resultobj = wxPyMake_wxObject(result, (bool)0);
46682 }
46683 return resultobj;
46684 fail:
46685 return NULL;
46686 }
46687
46688
46689 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46690 PyObject *resultobj = 0;
46691 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46692 wxSizer *arg2 = (wxSizer *) 0 ;
46693 void *argp1 = 0 ;
46694 int res1 = 0 ;
46695 int res2 = 0 ;
46696 PyObject * obj0 = 0 ;
46697 PyObject * obj1 = 0 ;
46698 char * kwnames[] = {
46699 (char *) "self",(char *) "sizer", NULL
46700 };
46701
46702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46704 if (!SWIG_IsOK(res1)) {
46705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46706 }
46707 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46708 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46709 if (!SWIG_IsOK(res2)) {
46710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46711 }
46712 {
46713 PyThreadState* __tstate = wxPyBeginAllowThreads();
46714 (arg1)->SetSizer(arg2);
46715 wxPyEndAllowThreads(__tstate);
46716 if (PyErr_Occurred()) SWIG_fail;
46717 }
46718 resultobj = SWIG_Py_Void();
46719 return resultobj;
46720 fail:
46721 return NULL;
46722 }
46723
46724
46725 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46726 PyObject *resultobj = 0;
46727 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46728 wxSize *result = 0 ;
46729 void *argp1 = 0 ;
46730 int res1 = 0 ;
46731 PyObject *swig_obj[1] ;
46732
46733 if (!args) SWIG_fail;
46734 swig_obj[0] = args;
46735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46736 if (!SWIG_IsOK(res1)) {
46737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46738 }
46739 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46740 {
46741 PyThreadState* __tstate = wxPyBeginAllowThreads();
46742 {
46743 wxSize const &_result_ref = (arg1)->GetSpacer();
46744 result = (wxSize *) &_result_ref;
46745 }
46746 wxPyEndAllowThreads(__tstate);
46747 if (PyErr_Occurred()) SWIG_fail;
46748 }
46749 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46750 return resultobj;
46751 fail:
46752 return NULL;
46753 }
46754
46755
46756 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46757 PyObject *resultobj = 0;
46758 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46759 wxSize *arg2 = 0 ;
46760 void *argp1 = 0 ;
46761 int res1 = 0 ;
46762 wxSize temp2 ;
46763 PyObject * obj0 = 0 ;
46764 PyObject * obj1 = 0 ;
46765 char * kwnames[] = {
46766 (char *) "self",(char *) "size", NULL
46767 };
46768
46769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46771 if (!SWIG_IsOK(res1)) {
46772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46773 }
46774 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46775 {
46776 arg2 = &temp2;
46777 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46778 }
46779 {
46780 PyThreadState* __tstate = wxPyBeginAllowThreads();
46781 (arg1)->SetSpacer((wxSize const &)*arg2);
46782 wxPyEndAllowThreads(__tstate);
46783 if (PyErr_Occurred()) SWIG_fail;
46784 }
46785 resultobj = SWIG_Py_Void();
46786 return resultobj;
46787 fail:
46788 return NULL;
46789 }
46790
46791
46792 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46793 PyObject *resultobj = 0;
46794 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46795 bool arg2 ;
46796 void *argp1 = 0 ;
46797 int res1 = 0 ;
46798 bool val2 ;
46799 int ecode2 = 0 ;
46800 PyObject * obj0 = 0 ;
46801 PyObject * obj1 = 0 ;
46802 char * kwnames[] = {
46803 (char *) "self",(char *) "show", NULL
46804 };
46805
46806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46808 if (!SWIG_IsOK(res1)) {
46809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46810 }
46811 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46812 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46813 if (!SWIG_IsOK(ecode2)) {
46814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46815 }
46816 arg2 = static_cast< bool >(val2);
46817 {
46818 PyThreadState* __tstate = wxPyBeginAllowThreads();
46819 (arg1)->Show(arg2);
46820 wxPyEndAllowThreads(__tstate);
46821 if (PyErr_Occurred()) SWIG_fail;
46822 }
46823 resultobj = SWIG_Py_Void();
46824 return resultobj;
46825 fail:
46826 return NULL;
46827 }
46828
46829
46830 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46831 PyObject *resultobj = 0;
46832 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46833 bool result;
46834 void *argp1 = 0 ;
46835 int res1 = 0 ;
46836 PyObject *swig_obj[1] ;
46837
46838 if (!args) SWIG_fail;
46839 swig_obj[0] = args;
46840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46841 if (!SWIG_IsOK(res1)) {
46842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46843 }
46844 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46845 {
46846 PyThreadState* __tstate = wxPyBeginAllowThreads();
46847 result = (bool)(arg1)->IsShown();
46848 wxPyEndAllowThreads(__tstate);
46849 if (PyErr_Occurred()) SWIG_fail;
46850 }
46851 {
46852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46853 }
46854 return resultobj;
46855 fail:
46856 return NULL;
46857 }
46858
46859
46860 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46861 PyObject *resultobj = 0;
46862 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46863 wxPoint result;
46864 void *argp1 = 0 ;
46865 int res1 = 0 ;
46866 PyObject *swig_obj[1] ;
46867
46868 if (!args) SWIG_fail;
46869 swig_obj[0] = args;
46870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46871 if (!SWIG_IsOK(res1)) {
46872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46873 }
46874 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46875 {
46876 PyThreadState* __tstate = wxPyBeginAllowThreads();
46877 result = (arg1)->GetPosition();
46878 wxPyEndAllowThreads(__tstate);
46879 if (PyErr_Occurred()) SWIG_fail;
46880 }
46881 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46882 return resultobj;
46883 fail:
46884 return NULL;
46885 }
46886
46887
46888 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46889 PyObject *resultobj = 0;
46890 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46891 PyObject *result = 0 ;
46892 void *argp1 = 0 ;
46893 int res1 = 0 ;
46894 PyObject *swig_obj[1] ;
46895
46896 if (!args) SWIG_fail;
46897 swig_obj[0] = args;
46898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46899 if (!SWIG_IsOK(res1)) {
46900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46901 }
46902 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46903 {
46904 PyThreadState* __tstate = wxPyBeginAllowThreads();
46905 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46906 wxPyEndAllowThreads(__tstate);
46907 if (PyErr_Occurred()) SWIG_fail;
46908 }
46909 resultobj = result;
46910 return resultobj;
46911 fail:
46912 return NULL;
46913 }
46914
46915
46916 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46917 PyObject *resultobj = 0;
46918 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46919 PyObject *arg2 = (PyObject *) 0 ;
46920 void *argp1 = 0 ;
46921 int res1 = 0 ;
46922 PyObject * obj0 = 0 ;
46923 PyObject * obj1 = 0 ;
46924 char * kwnames[] = {
46925 (char *) "self",(char *) "userData", NULL
46926 };
46927
46928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46930 if (!SWIG_IsOK(res1)) {
46931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46932 }
46933 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46934 arg2 = obj1;
46935 {
46936 PyThreadState* __tstate = wxPyBeginAllowThreads();
46937 wxSizerItem_SetUserData(arg1,arg2);
46938 wxPyEndAllowThreads(__tstate);
46939 if (PyErr_Occurred()) SWIG_fail;
46940 }
46941 resultobj = SWIG_Py_Void();
46942 return resultobj;
46943 fail:
46944 return NULL;
46945 }
46946
46947
46948 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46949 PyObject *obj;
46950 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46951 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46952 return SWIG_Py_Void();
46953 }
46954
46955 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46956 return SWIG_Python_InitShadowInstance(args);
46957 }
46958
46959 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46960 PyObject *resultobj = 0;
46961 wxSizer *arg1 = (wxSizer *) 0 ;
46962 void *argp1 = 0 ;
46963 int res1 = 0 ;
46964 PyObject *swig_obj[1] ;
46965
46966 if (!args) SWIG_fail;
46967 swig_obj[0] = args;
46968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46969 if (!SWIG_IsOK(res1)) {
46970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46971 }
46972 arg1 = reinterpret_cast< wxSizer * >(argp1);
46973 {
46974 PyThreadState* __tstate = wxPyBeginAllowThreads();
46975 delete arg1;
46976
46977 wxPyEndAllowThreads(__tstate);
46978 if (PyErr_Occurred()) SWIG_fail;
46979 }
46980 resultobj = SWIG_Py_Void();
46981 return resultobj;
46982 fail:
46983 return NULL;
46984 }
46985
46986
46987 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46988 PyObject *resultobj = 0;
46989 wxSizer *arg1 = (wxSizer *) 0 ;
46990 PyObject *arg2 = (PyObject *) 0 ;
46991 void *argp1 = 0 ;
46992 int res1 = 0 ;
46993 PyObject * obj0 = 0 ;
46994 PyObject * obj1 = 0 ;
46995 char * kwnames[] = {
46996 (char *) "self",(char *) "_self", NULL
46997 };
46998
46999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47001 if (!SWIG_IsOK(res1)) {
47002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47003 }
47004 arg1 = reinterpret_cast< wxSizer * >(argp1);
47005 arg2 = obj1;
47006 {
47007 PyThreadState* __tstate = wxPyBeginAllowThreads();
47008 wxSizer__setOORInfo(arg1,arg2);
47009 wxPyEndAllowThreads(__tstate);
47010 if (PyErr_Occurred()) SWIG_fail;
47011 }
47012 resultobj = SWIG_Py_Void();
47013 return resultobj;
47014 fail:
47015 return NULL;
47016 }
47017
47018
47019 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47020 PyObject *resultobj = 0;
47021 wxSizer *arg1 = (wxSizer *) 0 ;
47022 PyObject *arg2 = (PyObject *) 0 ;
47023 int arg3 = (int) 0 ;
47024 int arg4 = (int) 0 ;
47025 int arg5 = (int) 0 ;
47026 PyObject *arg6 = (PyObject *) NULL ;
47027 wxSizerItem *result = 0 ;
47028 void *argp1 = 0 ;
47029 int res1 = 0 ;
47030 int val3 ;
47031 int ecode3 = 0 ;
47032 int val4 ;
47033 int ecode4 = 0 ;
47034 int val5 ;
47035 int ecode5 = 0 ;
47036 PyObject * obj0 = 0 ;
47037 PyObject * obj1 = 0 ;
47038 PyObject * obj2 = 0 ;
47039 PyObject * obj3 = 0 ;
47040 PyObject * obj4 = 0 ;
47041 PyObject * obj5 = 0 ;
47042 char * kwnames[] = {
47043 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47044 };
47045
47046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47048 if (!SWIG_IsOK(res1)) {
47049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47050 }
47051 arg1 = reinterpret_cast< wxSizer * >(argp1);
47052 arg2 = obj1;
47053 if (obj2) {
47054 ecode3 = SWIG_AsVal_int(obj2, &val3);
47055 if (!SWIG_IsOK(ecode3)) {
47056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47057 }
47058 arg3 = static_cast< int >(val3);
47059 }
47060 if (obj3) {
47061 ecode4 = SWIG_AsVal_int(obj3, &val4);
47062 if (!SWIG_IsOK(ecode4)) {
47063 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47064 }
47065 arg4 = static_cast< int >(val4);
47066 }
47067 if (obj4) {
47068 ecode5 = SWIG_AsVal_int(obj4, &val5);
47069 if (!SWIG_IsOK(ecode5)) {
47070 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47071 }
47072 arg5 = static_cast< int >(val5);
47073 }
47074 if (obj5) {
47075 arg6 = obj5;
47076 }
47077 {
47078 PyThreadState* __tstate = wxPyBeginAllowThreads();
47079 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47080 wxPyEndAllowThreads(__tstate);
47081 if (PyErr_Occurred()) SWIG_fail;
47082 }
47083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47084 return resultobj;
47085 fail:
47086 return NULL;
47087 }
47088
47089
47090 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47091 PyObject *resultobj = 0;
47092 wxSizer *arg1 = (wxSizer *) 0 ;
47093 int arg2 ;
47094 PyObject *arg3 = (PyObject *) 0 ;
47095 int arg4 = (int) 0 ;
47096 int arg5 = (int) 0 ;
47097 int arg6 = (int) 0 ;
47098 PyObject *arg7 = (PyObject *) NULL ;
47099 wxSizerItem *result = 0 ;
47100 void *argp1 = 0 ;
47101 int res1 = 0 ;
47102 int val2 ;
47103 int ecode2 = 0 ;
47104 int val4 ;
47105 int ecode4 = 0 ;
47106 int val5 ;
47107 int ecode5 = 0 ;
47108 int val6 ;
47109 int ecode6 = 0 ;
47110 PyObject * obj0 = 0 ;
47111 PyObject * obj1 = 0 ;
47112 PyObject * obj2 = 0 ;
47113 PyObject * obj3 = 0 ;
47114 PyObject * obj4 = 0 ;
47115 PyObject * obj5 = 0 ;
47116 PyObject * obj6 = 0 ;
47117 char * kwnames[] = {
47118 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47119 };
47120
47121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47123 if (!SWIG_IsOK(res1)) {
47124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47125 }
47126 arg1 = reinterpret_cast< wxSizer * >(argp1);
47127 ecode2 = SWIG_AsVal_int(obj1, &val2);
47128 if (!SWIG_IsOK(ecode2)) {
47129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47130 }
47131 arg2 = static_cast< int >(val2);
47132 arg3 = obj2;
47133 if (obj3) {
47134 ecode4 = SWIG_AsVal_int(obj3, &val4);
47135 if (!SWIG_IsOK(ecode4)) {
47136 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47137 }
47138 arg4 = static_cast< int >(val4);
47139 }
47140 if (obj4) {
47141 ecode5 = SWIG_AsVal_int(obj4, &val5);
47142 if (!SWIG_IsOK(ecode5)) {
47143 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47144 }
47145 arg5 = static_cast< int >(val5);
47146 }
47147 if (obj5) {
47148 ecode6 = SWIG_AsVal_int(obj5, &val6);
47149 if (!SWIG_IsOK(ecode6)) {
47150 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47151 }
47152 arg6 = static_cast< int >(val6);
47153 }
47154 if (obj6) {
47155 arg7 = obj6;
47156 }
47157 {
47158 PyThreadState* __tstate = wxPyBeginAllowThreads();
47159 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47160 wxPyEndAllowThreads(__tstate);
47161 if (PyErr_Occurred()) SWIG_fail;
47162 }
47163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47164 return resultobj;
47165 fail:
47166 return NULL;
47167 }
47168
47169
47170 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47171 PyObject *resultobj = 0;
47172 wxSizer *arg1 = (wxSizer *) 0 ;
47173 PyObject *arg2 = (PyObject *) 0 ;
47174 int arg3 = (int) 0 ;
47175 int arg4 = (int) 0 ;
47176 int arg5 = (int) 0 ;
47177 PyObject *arg6 = (PyObject *) NULL ;
47178 wxSizerItem *result = 0 ;
47179 void *argp1 = 0 ;
47180 int res1 = 0 ;
47181 int val3 ;
47182 int ecode3 = 0 ;
47183 int val4 ;
47184 int ecode4 = 0 ;
47185 int val5 ;
47186 int ecode5 = 0 ;
47187 PyObject * obj0 = 0 ;
47188 PyObject * obj1 = 0 ;
47189 PyObject * obj2 = 0 ;
47190 PyObject * obj3 = 0 ;
47191 PyObject * obj4 = 0 ;
47192 PyObject * obj5 = 0 ;
47193 char * kwnames[] = {
47194 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47195 };
47196
47197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47201 }
47202 arg1 = reinterpret_cast< wxSizer * >(argp1);
47203 arg2 = obj1;
47204 if (obj2) {
47205 ecode3 = SWIG_AsVal_int(obj2, &val3);
47206 if (!SWIG_IsOK(ecode3)) {
47207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47208 }
47209 arg3 = static_cast< int >(val3);
47210 }
47211 if (obj3) {
47212 ecode4 = SWIG_AsVal_int(obj3, &val4);
47213 if (!SWIG_IsOK(ecode4)) {
47214 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47215 }
47216 arg4 = static_cast< int >(val4);
47217 }
47218 if (obj4) {
47219 ecode5 = SWIG_AsVal_int(obj4, &val5);
47220 if (!SWIG_IsOK(ecode5)) {
47221 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47222 }
47223 arg5 = static_cast< int >(val5);
47224 }
47225 if (obj5) {
47226 arg6 = obj5;
47227 }
47228 {
47229 PyThreadState* __tstate = wxPyBeginAllowThreads();
47230 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47231 wxPyEndAllowThreads(__tstate);
47232 if (PyErr_Occurred()) SWIG_fail;
47233 }
47234 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47235 return resultobj;
47236 fail:
47237 return NULL;
47238 }
47239
47240
47241 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47242 PyObject *resultobj = 0;
47243 wxSizer *arg1 = (wxSizer *) 0 ;
47244 PyObject *arg2 = (PyObject *) 0 ;
47245 bool result;
47246 void *argp1 = 0 ;
47247 int res1 = 0 ;
47248 PyObject * obj0 = 0 ;
47249 PyObject * obj1 = 0 ;
47250 char * kwnames[] = {
47251 (char *) "self",(char *) "item", NULL
47252 };
47253
47254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47256 if (!SWIG_IsOK(res1)) {
47257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47258 }
47259 arg1 = reinterpret_cast< wxSizer * >(argp1);
47260 arg2 = obj1;
47261 {
47262 PyThreadState* __tstate = wxPyBeginAllowThreads();
47263 result = (bool)wxSizer_Remove(arg1,arg2);
47264 wxPyEndAllowThreads(__tstate);
47265 if (PyErr_Occurred()) SWIG_fail;
47266 }
47267 {
47268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47269 }
47270 return resultobj;
47271 fail:
47272 return NULL;
47273 }
47274
47275
47276 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47277 PyObject *resultobj = 0;
47278 wxSizer *arg1 = (wxSizer *) 0 ;
47279 PyObject *arg2 = (PyObject *) 0 ;
47280 bool result;
47281 void *argp1 = 0 ;
47282 int res1 = 0 ;
47283 PyObject * obj0 = 0 ;
47284 PyObject * obj1 = 0 ;
47285 char * kwnames[] = {
47286 (char *) "self",(char *) "item", NULL
47287 };
47288
47289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47291 if (!SWIG_IsOK(res1)) {
47292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47293 }
47294 arg1 = reinterpret_cast< wxSizer * >(argp1);
47295 arg2 = obj1;
47296 {
47297 PyThreadState* __tstate = wxPyBeginAllowThreads();
47298 result = (bool)wxSizer_Detach(arg1,arg2);
47299 wxPyEndAllowThreads(__tstate);
47300 if (PyErr_Occurred()) SWIG_fail;
47301 }
47302 {
47303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47304 }
47305 return resultobj;
47306 fail:
47307 return NULL;
47308 }
47309
47310
47311 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47312 PyObject *resultobj = 0;
47313 wxSizer *arg1 = (wxSizer *) 0 ;
47314 PyObject *arg2 = (PyObject *) 0 ;
47315 wxSizerItem *result = 0 ;
47316 void *argp1 = 0 ;
47317 int res1 = 0 ;
47318 PyObject * obj0 = 0 ;
47319 PyObject * obj1 = 0 ;
47320 char * kwnames[] = {
47321 (char *) "self",(char *) "item", NULL
47322 };
47323
47324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47326 if (!SWIG_IsOK(res1)) {
47327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47328 }
47329 arg1 = reinterpret_cast< wxSizer * >(argp1);
47330 arg2 = obj1;
47331 {
47332 PyThreadState* __tstate = wxPyBeginAllowThreads();
47333 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47334 wxPyEndAllowThreads(__tstate);
47335 if (PyErr_Occurred()) SWIG_fail;
47336 }
47337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47338 return resultobj;
47339 fail:
47340 return NULL;
47341 }
47342
47343
47344 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47345 PyObject *resultobj = 0;
47346 wxSizer *arg1 = (wxSizer *) 0 ;
47347 PyObject *arg2 = (PyObject *) 0 ;
47348 wxSize *arg3 = 0 ;
47349 void *argp1 = 0 ;
47350 int res1 = 0 ;
47351 wxSize temp3 ;
47352 PyObject * obj0 = 0 ;
47353 PyObject * obj1 = 0 ;
47354 PyObject * obj2 = 0 ;
47355 char * kwnames[] = {
47356 (char *) "self",(char *) "item",(char *) "size", NULL
47357 };
47358
47359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47361 if (!SWIG_IsOK(res1)) {
47362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47363 }
47364 arg1 = reinterpret_cast< wxSizer * >(argp1);
47365 arg2 = obj1;
47366 {
47367 arg3 = &temp3;
47368 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47369 }
47370 {
47371 PyThreadState* __tstate = wxPyBeginAllowThreads();
47372 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47373 wxPyEndAllowThreads(__tstate);
47374 if (PyErr_Occurred()) SWIG_fail;
47375 }
47376 resultobj = SWIG_Py_Void();
47377 return resultobj;
47378 fail:
47379 return NULL;
47380 }
47381
47382
47383 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47384 PyObject *resultobj = 0;
47385 wxSizer *arg1 = (wxSizer *) 0 ;
47386 wxWindow *arg2 = (wxWindow *) 0 ;
47387 wxWindow *arg3 = (wxWindow *) 0 ;
47388 bool arg4 = (bool) false ;
47389 bool result;
47390 void *argp1 = 0 ;
47391 int res1 = 0 ;
47392 void *argp2 = 0 ;
47393 int res2 = 0 ;
47394 void *argp3 = 0 ;
47395 int res3 = 0 ;
47396 bool val4 ;
47397 int ecode4 = 0 ;
47398 PyObject * obj0 = 0 ;
47399 PyObject * obj1 = 0 ;
47400 PyObject * obj2 = 0 ;
47401 PyObject * obj3 = 0 ;
47402 char * kwnames[] = {
47403 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47404 };
47405
47406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47408 if (!SWIG_IsOK(res1)) {
47409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47410 }
47411 arg1 = reinterpret_cast< wxSizer * >(argp1);
47412 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47413 if (!SWIG_IsOK(res2)) {
47414 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47415 }
47416 arg2 = reinterpret_cast< wxWindow * >(argp2);
47417 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47418 if (!SWIG_IsOK(res3)) {
47419 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47420 }
47421 arg3 = reinterpret_cast< wxWindow * >(argp3);
47422 if (obj3) {
47423 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47424 if (!SWIG_IsOK(ecode4)) {
47425 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47426 }
47427 arg4 = static_cast< bool >(val4);
47428 }
47429 {
47430 PyThreadState* __tstate = wxPyBeginAllowThreads();
47431 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47432 wxPyEndAllowThreads(__tstate);
47433 if (PyErr_Occurred()) SWIG_fail;
47434 }
47435 {
47436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47437 }
47438 return resultobj;
47439 fail:
47440 return NULL;
47441 }
47442
47443
47444 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47445 PyObject *resultobj = 0;
47446 wxSizer *arg1 = (wxSizer *) 0 ;
47447 wxSizer *arg2 = (wxSizer *) 0 ;
47448 wxSizer *arg3 = (wxSizer *) 0 ;
47449 bool arg4 = (bool) false ;
47450 bool result;
47451 void *argp1 = 0 ;
47452 int res1 = 0 ;
47453 void *argp2 = 0 ;
47454 int res2 = 0 ;
47455 void *argp3 = 0 ;
47456 int res3 = 0 ;
47457 bool val4 ;
47458 int ecode4 = 0 ;
47459 PyObject * obj0 = 0 ;
47460 PyObject * obj1 = 0 ;
47461 PyObject * obj2 = 0 ;
47462 PyObject * obj3 = 0 ;
47463 char * kwnames[] = {
47464 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47465 };
47466
47467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47469 if (!SWIG_IsOK(res1)) {
47470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47471 }
47472 arg1 = reinterpret_cast< wxSizer * >(argp1);
47473 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47474 if (!SWIG_IsOK(res2)) {
47475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47476 }
47477 arg2 = reinterpret_cast< wxSizer * >(argp2);
47478 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47479 if (!SWIG_IsOK(res3)) {
47480 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47481 }
47482 arg3 = reinterpret_cast< wxSizer * >(argp3);
47483 if (obj3) {
47484 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47485 if (!SWIG_IsOK(ecode4)) {
47486 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47487 }
47488 arg4 = static_cast< bool >(val4);
47489 }
47490 {
47491 PyThreadState* __tstate = wxPyBeginAllowThreads();
47492 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47493 wxPyEndAllowThreads(__tstate);
47494 if (PyErr_Occurred()) SWIG_fail;
47495 }
47496 {
47497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47498 }
47499 return resultobj;
47500 fail:
47501 return NULL;
47502 }
47503
47504
47505 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47506 PyObject *resultobj = 0;
47507 wxSizer *arg1 = (wxSizer *) 0 ;
47508 size_t arg2 ;
47509 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47510 bool result;
47511 void *argp1 = 0 ;
47512 int res1 = 0 ;
47513 size_t val2 ;
47514 int ecode2 = 0 ;
47515 void *argp3 = 0 ;
47516 int res3 = 0 ;
47517 PyObject * obj0 = 0 ;
47518 PyObject * obj1 = 0 ;
47519 PyObject * obj2 = 0 ;
47520 char * kwnames[] = {
47521 (char *) "self",(char *) "index",(char *) "newitem", NULL
47522 };
47523
47524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47526 if (!SWIG_IsOK(res1)) {
47527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47528 }
47529 arg1 = reinterpret_cast< wxSizer * >(argp1);
47530 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47531 if (!SWIG_IsOK(ecode2)) {
47532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
47533 }
47534 arg2 = static_cast< size_t >(val2);
47535 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47536 if (!SWIG_IsOK(res3)) {
47537 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47538 }
47539 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
47540 {
47541 PyThreadState* __tstate = wxPyBeginAllowThreads();
47542 result = (bool)(arg1)->Replace(arg2,arg3);
47543 wxPyEndAllowThreads(__tstate);
47544 if (PyErr_Occurred()) SWIG_fail;
47545 }
47546 {
47547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47548 }
47549 return resultobj;
47550 fail:
47551 return NULL;
47552 }
47553
47554
47555 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47556 PyObject *resultobj = 0;
47557 wxSizer *arg1 = (wxSizer *) 0 ;
47558 wxWindow *arg2 = (wxWindow *) 0 ;
47559 void *argp1 = 0 ;
47560 int res1 = 0 ;
47561 void *argp2 = 0 ;
47562 int res2 = 0 ;
47563 PyObject * obj0 = 0 ;
47564 PyObject * obj1 = 0 ;
47565 char * kwnames[] = {
47566 (char *) "self",(char *) "window", NULL
47567 };
47568
47569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47571 if (!SWIG_IsOK(res1)) {
47572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
47573 }
47574 arg1 = reinterpret_cast< wxSizer * >(argp1);
47575 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47576 if (!SWIG_IsOK(res2)) {
47577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47578 }
47579 arg2 = reinterpret_cast< wxWindow * >(argp2);
47580 {
47581 PyThreadState* __tstate = wxPyBeginAllowThreads();
47582 (arg1)->SetContainingWindow(arg2);
47583 wxPyEndAllowThreads(__tstate);
47584 if (PyErr_Occurred()) SWIG_fail;
47585 }
47586 resultobj = SWIG_Py_Void();
47587 return resultobj;
47588 fail:
47589 return NULL;
47590 }
47591
47592
47593 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47594 PyObject *resultobj = 0;
47595 wxSizer *arg1 = (wxSizer *) 0 ;
47596 wxWindow *result = 0 ;
47597 void *argp1 = 0 ;
47598 int res1 = 0 ;
47599 PyObject *swig_obj[1] ;
47600
47601 if (!args) SWIG_fail;
47602 swig_obj[0] = args;
47603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47604 if (!SWIG_IsOK(res1)) {
47605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
47606 }
47607 arg1 = reinterpret_cast< wxSizer * >(argp1);
47608 {
47609 PyThreadState* __tstate = wxPyBeginAllowThreads();
47610 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
47611 wxPyEndAllowThreads(__tstate);
47612 if (PyErr_Occurred()) SWIG_fail;
47613 }
47614 {
47615 resultobj = wxPyMake_wxObject(result, 0);
47616 }
47617 return resultobj;
47618 fail:
47619 return NULL;
47620 }
47621
47622
47623 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47624 PyObject *resultobj = 0;
47625 wxSizer *arg1 = (wxSizer *) 0 ;
47626 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47627 wxSizerItem *result = 0 ;
47628 void *argp1 = 0 ;
47629 int res1 = 0 ;
47630 int res2 = 0 ;
47631 PyObject * obj0 = 0 ;
47632 PyObject * obj1 = 0 ;
47633 char * kwnames[] = {
47634 (char *) "self",(char *) "item", NULL
47635 };
47636
47637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47639 if (!SWIG_IsOK(res1)) {
47640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47641 }
47642 arg1 = reinterpret_cast< wxSizer * >(argp1);
47643 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47644 if (!SWIG_IsOK(res2)) {
47645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47646 }
47647 {
47648 PyThreadState* __tstate = wxPyBeginAllowThreads();
47649 result = (wxSizerItem *)(arg1)->Add(arg2);
47650 wxPyEndAllowThreads(__tstate);
47651 if (PyErr_Occurred()) SWIG_fail;
47652 }
47653 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47654 return resultobj;
47655 fail:
47656 return NULL;
47657 }
47658
47659
47660 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47661 PyObject *resultobj = 0;
47662 wxSizer *arg1 = (wxSizer *) 0 ;
47663 size_t arg2 ;
47664 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47665 wxSizerItem *result = 0 ;
47666 void *argp1 = 0 ;
47667 int res1 = 0 ;
47668 size_t val2 ;
47669 int ecode2 = 0 ;
47670 int res3 = 0 ;
47671 PyObject * obj0 = 0 ;
47672 PyObject * obj1 = 0 ;
47673 PyObject * obj2 = 0 ;
47674 char * kwnames[] = {
47675 (char *) "self",(char *) "index",(char *) "item", NULL
47676 };
47677
47678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47680 if (!SWIG_IsOK(res1)) {
47681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47682 }
47683 arg1 = reinterpret_cast< wxSizer * >(argp1);
47684 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47685 if (!SWIG_IsOK(ecode2)) {
47686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47687 }
47688 arg2 = static_cast< size_t >(val2);
47689 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47690 if (!SWIG_IsOK(res3)) {
47691 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47692 }
47693 {
47694 PyThreadState* __tstate = wxPyBeginAllowThreads();
47695 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47696 wxPyEndAllowThreads(__tstate);
47697 if (PyErr_Occurred()) SWIG_fail;
47698 }
47699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47700 return resultobj;
47701 fail:
47702 return NULL;
47703 }
47704
47705
47706 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47707 PyObject *resultobj = 0;
47708 wxSizer *arg1 = (wxSizer *) 0 ;
47709 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47710 wxSizerItem *result = 0 ;
47711 void *argp1 = 0 ;
47712 int res1 = 0 ;
47713 int res2 = 0 ;
47714 PyObject * obj0 = 0 ;
47715 PyObject * obj1 = 0 ;
47716 char * kwnames[] = {
47717 (char *) "self",(char *) "item", NULL
47718 };
47719
47720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47722 if (!SWIG_IsOK(res1)) {
47723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47724 }
47725 arg1 = reinterpret_cast< wxSizer * >(argp1);
47726 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47727 if (!SWIG_IsOK(res2)) {
47728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47729 }
47730 {
47731 PyThreadState* __tstate = wxPyBeginAllowThreads();
47732 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47733 wxPyEndAllowThreads(__tstate);
47734 if (PyErr_Occurred()) SWIG_fail;
47735 }
47736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47737 return resultobj;
47738 fail:
47739 return NULL;
47740 }
47741
47742
47743 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47744 PyObject *resultobj = 0;
47745 wxSizer *arg1 = (wxSizer *) 0 ;
47746 int arg2 ;
47747 int arg3 ;
47748 int arg4 ;
47749 int arg5 ;
47750 void *argp1 = 0 ;
47751 int res1 = 0 ;
47752 int val2 ;
47753 int ecode2 = 0 ;
47754 int val3 ;
47755 int ecode3 = 0 ;
47756 int val4 ;
47757 int ecode4 = 0 ;
47758 int val5 ;
47759 int ecode5 = 0 ;
47760 PyObject * obj0 = 0 ;
47761 PyObject * obj1 = 0 ;
47762 PyObject * obj2 = 0 ;
47763 PyObject * obj3 = 0 ;
47764 PyObject * obj4 = 0 ;
47765 char * kwnames[] = {
47766 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47767 };
47768
47769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47771 if (!SWIG_IsOK(res1)) {
47772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47773 }
47774 arg1 = reinterpret_cast< wxSizer * >(argp1);
47775 ecode2 = SWIG_AsVal_int(obj1, &val2);
47776 if (!SWIG_IsOK(ecode2)) {
47777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47778 }
47779 arg2 = static_cast< int >(val2);
47780 ecode3 = SWIG_AsVal_int(obj2, &val3);
47781 if (!SWIG_IsOK(ecode3)) {
47782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47783 }
47784 arg3 = static_cast< int >(val3);
47785 ecode4 = SWIG_AsVal_int(obj3, &val4);
47786 if (!SWIG_IsOK(ecode4)) {
47787 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47788 }
47789 arg4 = static_cast< int >(val4);
47790 ecode5 = SWIG_AsVal_int(obj4, &val5);
47791 if (!SWIG_IsOK(ecode5)) {
47792 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47793 }
47794 arg5 = static_cast< int >(val5);
47795 {
47796 PyThreadState* __tstate = wxPyBeginAllowThreads();
47797 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47798 wxPyEndAllowThreads(__tstate);
47799 if (PyErr_Occurred()) SWIG_fail;
47800 }
47801 resultobj = SWIG_Py_Void();
47802 return resultobj;
47803 fail:
47804 return NULL;
47805 }
47806
47807
47808 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47809 PyObject *resultobj = 0;
47810 wxSizer *arg1 = (wxSizer *) 0 ;
47811 wxSize *arg2 = 0 ;
47812 void *argp1 = 0 ;
47813 int res1 = 0 ;
47814 wxSize temp2 ;
47815 PyObject * obj0 = 0 ;
47816 PyObject * obj1 = 0 ;
47817 char * kwnames[] = {
47818 (char *) "self",(char *) "size", NULL
47819 };
47820
47821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47823 if (!SWIG_IsOK(res1)) {
47824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47825 }
47826 arg1 = reinterpret_cast< wxSizer * >(argp1);
47827 {
47828 arg2 = &temp2;
47829 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47830 }
47831 {
47832 PyThreadState* __tstate = wxPyBeginAllowThreads();
47833 (arg1)->SetMinSize((wxSize const &)*arg2);
47834 wxPyEndAllowThreads(__tstate);
47835 if (PyErr_Occurred()) SWIG_fail;
47836 }
47837 resultobj = SWIG_Py_Void();
47838 return resultobj;
47839 fail:
47840 return NULL;
47841 }
47842
47843
47844 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47845 PyObject *resultobj = 0;
47846 wxSizer *arg1 = (wxSizer *) 0 ;
47847 wxSize result;
47848 void *argp1 = 0 ;
47849 int res1 = 0 ;
47850 PyObject *swig_obj[1] ;
47851
47852 if (!args) SWIG_fail;
47853 swig_obj[0] = args;
47854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47855 if (!SWIG_IsOK(res1)) {
47856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47857 }
47858 arg1 = reinterpret_cast< wxSizer * >(argp1);
47859 {
47860 PyThreadState* __tstate = wxPyBeginAllowThreads();
47861 result = (arg1)->GetSize();
47862 wxPyEndAllowThreads(__tstate);
47863 if (PyErr_Occurred()) SWIG_fail;
47864 }
47865 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47866 return resultobj;
47867 fail:
47868 return NULL;
47869 }
47870
47871
47872 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47873 PyObject *resultobj = 0;
47874 wxSizer *arg1 = (wxSizer *) 0 ;
47875 wxPoint result;
47876 void *argp1 = 0 ;
47877 int res1 = 0 ;
47878 PyObject *swig_obj[1] ;
47879
47880 if (!args) SWIG_fail;
47881 swig_obj[0] = args;
47882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47883 if (!SWIG_IsOK(res1)) {
47884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47885 }
47886 arg1 = reinterpret_cast< wxSizer * >(argp1);
47887 {
47888 PyThreadState* __tstate = wxPyBeginAllowThreads();
47889 result = (arg1)->GetPosition();
47890 wxPyEndAllowThreads(__tstate);
47891 if (PyErr_Occurred()) SWIG_fail;
47892 }
47893 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47894 return resultobj;
47895 fail:
47896 return NULL;
47897 }
47898
47899
47900 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47901 PyObject *resultobj = 0;
47902 wxSizer *arg1 = (wxSizer *) 0 ;
47903 wxSize result;
47904 void *argp1 = 0 ;
47905 int res1 = 0 ;
47906 PyObject *swig_obj[1] ;
47907
47908 if (!args) SWIG_fail;
47909 swig_obj[0] = args;
47910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47911 if (!SWIG_IsOK(res1)) {
47912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47913 }
47914 arg1 = reinterpret_cast< wxSizer * >(argp1);
47915 {
47916 PyThreadState* __tstate = wxPyBeginAllowThreads();
47917 result = (arg1)->GetMinSize();
47918 wxPyEndAllowThreads(__tstate);
47919 if (PyErr_Occurred()) SWIG_fail;
47920 }
47921 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47922 return resultobj;
47923 fail:
47924 return NULL;
47925 }
47926
47927
47928 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47929 PyObject *resultobj = 0;
47930 wxSizer *arg1 = (wxSizer *) 0 ;
47931 void *argp1 = 0 ;
47932 int res1 = 0 ;
47933 PyObject *swig_obj[1] ;
47934
47935 if (!args) SWIG_fail;
47936 swig_obj[0] = args;
47937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47938 if (!SWIG_IsOK(res1)) {
47939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47940 }
47941 arg1 = reinterpret_cast< wxSizer * >(argp1);
47942 {
47943 PyThreadState* __tstate = wxPyBeginAllowThreads();
47944 (arg1)->RecalcSizes();
47945 wxPyEndAllowThreads(__tstate);
47946 if (PyErr_Occurred()) SWIG_fail;
47947 }
47948 resultobj = SWIG_Py_Void();
47949 return resultobj;
47950 fail:
47951 return NULL;
47952 }
47953
47954
47955 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47956 PyObject *resultobj = 0;
47957 wxSizer *arg1 = (wxSizer *) 0 ;
47958 wxSize result;
47959 void *argp1 = 0 ;
47960 int res1 = 0 ;
47961 PyObject *swig_obj[1] ;
47962
47963 if (!args) SWIG_fail;
47964 swig_obj[0] = args;
47965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47966 if (!SWIG_IsOK(res1)) {
47967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47968 }
47969 arg1 = reinterpret_cast< wxSizer * >(argp1);
47970 {
47971 PyThreadState* __tstate = wxPyBeginAllowThreads();
47972 result = (arg1)->CalcMin();
47973 wxPyEndAllowThreads(__tstate);
47974 if (PyErr_Occurred()) SWIG_fail;
47975 }
47976 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47977 return resultobj;
47978 fail:
47979 return NULL;
47980 }
47981
47982
47983 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47984 PyObject *resultobj = 0;
47985 wxSizer *arg1 = (wxSizer *) 0 ;
47986 void *argp1 = 0 ;
47987 int res1 = 0 ;
47988 PyObject *swig_obj[1] ;
47989
47990 if (!args) SWIG_fail;
47991 swig_obj[0] = args;
47992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47993 if (!SWIG_IsOK(res1)) {
47994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47995 }
47996 arg1 = reinterpret_cast< wxSizer * >(argp1);
47997 {
47998 PyThreadState* __tstate = wxPyBeginAllowThreads();
47999 (arg1)->Layout();
48000 wxPyEndAllowThreads(__tstate);
48001 if (PyErr_Occurred()) SWIG_fail;
48002 }
48003 resultobj = SWIG_Py_Void();
48004 return resultobj;
48005 fail:
48006 return NULL;
48007 }
48008
48009
48010 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48011 PyObject *resultobj = 0;
48012 wxSizer *arg1 = (wxSizer *) 0 ;
48013 wxWindow *arg2 = (wxWindow *) 0 ;
48014 wxSize result;
48015 void *argp1 = 0 ;
48016 int res1 = 0 ;
48017 void *argp2 = 0 ;
48018 int res2 = 0 ;
48019 PyObject * obj0 = 0 ;
48020 PyObject * obj1 = 0 ;
48021 char * kwnames[] = {
48022 (char *) "self",(char *) "window", NULL
48023 };
48024
48025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48027 if (!SWIG_IsOK(res1)) {
48028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48029 }
48030 arg1 = reinterpret_cast< wxSizer * >(argp1);
48031 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48032 if (!SWIG_IsOK(res2)) {
48033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48034 }
48035 arg2 = reinterpret_cast< wxWindow * >(argp2);
48036 {
48037 PyThreadState* __tstate = wxPyBeginAllowThreads();
48038 result = (arg1)->Fit(arg2);
48039 wxPyEndAllowThreads(__tstate);
48040 if (PyErr_Occurred()) SWIG_fail;
48041 }
48042 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48043 return resultobj;
48044 fail:
48045 return NULL;
48046 }
48047
48048
48049 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48050 PyObject *resultobj = 0;
48051 wxSizer *arg1 = (wxSizer *) 0 ;
48052 wxWindow *arg2 = (wxWindow *) 0 ;
48053 void *argp1 = 0 ;
48054 int res1 = 0 ;
48055 void *argp2 = 0 ;
48056 int res2 = 0 ;
48057 PyObject * obj0 = 0 ;
48058 PyObject * obj1 = 0 ;
48059 char * kwnames[] = {
48060 (char *) "self",(char *) "window", NULL
48061 };
48062
48063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48065 if (!SWIG_IsOK(res1)) {
48066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48067 }
48068 arg1 = reinterpret_cast< wxSizer * >(argp1);
48069 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48070 if (!SWIG_IsOK(res2)) {
48071 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48072 }
48073 arg2 = reinterpret_cast< wxWindow * >(argp2);
48074 {
48075 PyThreadState* __tstate = wxPyBeginAllowThreads();
48076 (arg1)->FitInside(arg2);
48077 wxPyEndAllowThreads(__tstate);
48078 if (PyErr_Occurred()) SWIG_fail;
48079 }
48080 resultobj = SWIG_Py_Void();
48081 return resultobj;
48082 fail:
48083 return NULL;
48084 }
48085
48086
48087 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48088 PyObject *resultobj = 0;
48089 wxSizer *arg1 = (wxSizer *) 0 ;
48090 wxWindow *arg2 = (wxWindow *) 0 ;
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_SetSizeHints",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_SetSizeHints" "', 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_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48110 }
48111 arg2 = reinterpret_cast< wxWindow * >(argp2);
48112 {
48113 PyThreadState* __tstate = wxPyBeginAllowThreads();
48114 (arg1)->SetSizeHints(arg2);
48115 wxPyEndAllowThreads(__tstate);
48116 if (PyErr_Occurred()) SWIG_fail;
48117 }
48118 resultobj = SWIG_Py_Void();
48119 return resultobj;
48120 fail:
48121 return NULL;
48122 }
48123
48124
48125 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(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_SetVirtualSizeHints",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_SetVirtualSizeHints" "', 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_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48148 }
48149 arg2 = reinterpret_cast< wxWindow * >(argp2);
48150 {
48151 PyThreadState* __tstate = wxPyBeginAllowThreads();
48152 (arg1)->SetVirtualSizeHints(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_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48164 PyObject *resultobj = 0;
48165 wxSizer *arg1 = (wxSizer *) 0 ;
48166 bool arg2 = (bool) false ;
48167 void *argp1 = 0 ;
48168 int res1 = 0 ;
48169 bool val2 ;
48170 int ecode2 = 0 ;
48171 PyObject * obj0 = 0 ;
48172 PyObject * obj1 = 0 ;
48173 char * kwnames[] = {
48174 (char *) "self",(char *) "deleteWindows", NULL
48175 };
48176
48177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",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_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48181 }
48182 arg1 = reinterpret_cast< wxSizer * >(argp1);
48183 if (obj1) {
48184 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48185 if (!SWIG_IsOK(ecode2)) {
48186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48187 }
48188 arg2 = static_cast< bool >(val2);
48189 }
48190 {
48191 PyThreadState* __tstate = wxPyBeginAllowThreads();
48192 (arg1)->Clear(arg2);
48193 wxPyEndAllowThreads(__tstate);
48194 if (PyErr_Occurred()) SWIG_fail;
48195 }
48196 resultobj = SWIG_Py_Void();
48197 return resultobj;
48198 fail:
48199 return NULL;
48200 }
48201
48202
48203 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48204 PyObject *resultobj = 0;
48205 wxSizer *arg1 = (wxSizer *) 0 ;
48206 void *argp1 = 0 ;
48207 int res1 = 0 ;
48208 PyObject *swig_obj[1] ;
48209
48210 if (!args) SWIG_fail;
48211 swig_obj[0] = args;
48212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48213 if (!SWIG_IsOK(res1)) {
48214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48215 }
48216 arg1 = reinterpret_cast< wxSizer * >(argp1);
48217 {
48218 PyThreadState* __tstate = wxPyBeginAllowThreads();
48219 (arg1)->DeleteWindows();
48220 wxPyEndAllowThreads(__tstate);
48221 if (PyErr_Occurred()) SWIG_fail;
48222 }
48223 resultobj = SWIG_Py_Void();
48224 return resultobj;
48225 fail:
48226 return NULL;
48227 }
48228
48229
48230 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48231 PyObject *resultobj = 0;
48232 wxSizer *arg1 = (wxSizer *) 0 ;
48233 PyObject *result = 0 ;
48234 void *argp1 = 0 ;
48235 int res1 = 0 ;
48236 PyObject *swig_obj[1] ;
48237
48238 if (!args) SWIG_fail;
48239 swig_obj[0] = args;
48240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48241 if (!SWIG_IsOK(res1)) {
48242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48243 }
48244 arg1 = reinterpret_cast< wxSizer * >(argp1);
48245 {
48246 PyThreadState* __tstate = wxPyBeginAllowThreads();
48247 result = (PyObject *)wxSizer_GetChildren(arg1);
48248 wxPyEndAllowThreads(__tstate);
48249 if (PyErr_Occurred()) SWIG_fail;
48250 }
48251 resultobj = result;
48252 return resultobj;
48253 fail:
48254 return NULL;
48255 }
48256
48257
48258 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48259 PyObject *resultobj = 0;
48260 wxSizer *arg1 = (wxSizer *) 0 ;
48261 PyObject *arg2 = (PyObject *) 0 ;
48262 bool arg3 = (bool) true ;
48263 bool arg4 = (bool) false ;
48264 bool result;
48265 void *argp1 = 0 ;
48266 int res1 = 0 ;
48267 bool val3 ;
48268 int ecode3 = 0 ;
48269 bool val4 ;
48270 int ecode4 = 0 ;
48271 PyObject * obj0 = 0 ;
48272 PyObject * obj1 = 0 ;
48273 PyObject * obj2 = 0 ;
48274 PyObject * obj3 = 0 ;
48275 char * kwnames[] = {
48276 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48277 };
48278
48279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48281 if (!SWIG_IsOK(res1)) {
48282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48283 }
48284 arg1 = reinterpret_cast< wxSizer * >(argp1);
48285 arg2 = obj1;
48286 if (obj2) {
48287 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48288 if (!SWIG_IsOK(ecode3)) {
48289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48290 }
48291 arg3 = static_cast< bool >(val3);
48292 }
48293 if (obj3) {
48294 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48295 if (!SWIG_IsOK(ecode4)) {
48296 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48297 }
48298 arg4 = static_cast< bool >(val4);
48299 }
48300 {
48301 PyThreadState* __tstate = wxPyBeginAllowThreads();
48302 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48303 wxPyEndAllowThreads(__tstate);
48304 if (PyErr_Occurred()) SWIG_fail;
48305 }
48306 {
48307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48308 }
48309 return resultobj;
48310 fail:
48311 return NULL;
48312 }
48313
48314
48315 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48316 PyObject *resultobj = 0;
48317 wxSizer *arg1 = (wxSizer *) 0 ;
48318 PyObject *arg2 = (PyObject *) 0 ;
48319 bool result;
48320 void *argp1 = 0 ;
48321 int res1 = 0 ;
48322 PyObject * obj0 = 0 ;
48323 PyObject * obj1 = 0 ;
48324 char * kwnames[] = {
48325 (char *) "self",(char *) "item", NULL
48326 };
48327
48328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48330 if (!SWIG_IsOK(res1)) {
48331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48332 }
48333 arg1 = reinterpret_cast< wxSizer * >(argp1);
48334 arg2 = obj1;
48335 {
48336 PyThreadState* __tstate = wxPyBeginAllowThreads();
48337 result = (bool)wxSizer_IsShown(arg1,arg2);
48338 wxPyEndAllowThreads(__tstate);
48339 if (PyErr_Occurred()) SWIG_fail;
48340 }
48341 {
48342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48343 }
48344 return resultobj;
48345 fail:
48346 return NULL;
48347 }
48348
48349
48350 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48351 PyObject *resultobj = 0;
48352 wxSizer *arg1 = (wxSizer *) 0 ;
48353 bool arg2 ;
48354 void *argp1 = 0 ;
48355 int res1 = 0 ;
48356 bool val2 ;
48357 int ecode2 = 0 ;
48358 PyObject * obj0 = 0 ;
48359 PyObject * obj1 = 0 ;
48360 char * kwnames[] = {
48361 (char *) "self",(char *) "show", NULL
48362 };
48363
48364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48366 if (!SWIG_IsOK(res1)) {
48367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48368 }
48369 arg1 = reinterpret_cast< wxSizer * >(argp1);
48370 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48371 if (!SWIG_IsOK(ecode2)) {
48372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48373 }
48374 arg2 = static_cast< bool >(val2);
48375 {
48376 PyThreadState* __tstate = wxPyBeginAllowThreads();
48377 (arg1)->ShowItems(arg2);
48378 wxPyEndAllowThreads(__tstate);
48379 if (PyErr_Occurred()) SWIG_fail;
48380 }
48381 resultobj = SWIG_Py_Void();
48382 return resultobj;
48383 fail:
48384 return NULL;
48385 }
48386
48387
48388 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48389 PyObject *obj;
48390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48391 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
48392 return SWIG_Py_Void();
48393 }
48394
48395 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48396 PyObject *resultobj = 0;
48397 wxPySizer *result = 0 ;
48398
48399 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48400 {
48401 PyThreadState* __tstate = wxPyBeginAllowThreads();
48402 result = (wxPySizer *)new wxPySizer();
48403 wxPyEndAllowThreads(__tstate);
48404 if (PyErr_Occurred()) SWIG_fail;
48405 }
48406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48407 return resultobj;
48408 fail:
48409 return NULL;
48410 }
48411
48412
48413 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48414 PyObject *resultobj = 0;
48415 wxPySizer *arg1 = (wxPySizer *) 0 ;
48416 PyObject *arg2 = (PyObject *) 0 ;
48417 PyObject *arg3 = (PyObject *) 0 ;
48418 void *argp1 = 0 ;
48419 int res1 = 0 ;
48420 PyObject * obj0 = 0 ;
48421 PyObject * obj1 = 0 ;
48422 PyObject * obj2 = 0 ;
48423 char * kwnames[] = {
48424 (char *) "self",(char *) "self",(char *) "_class", NULL
48425 };
48426
48427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48429 if (!SWIG_IsOK(res1)) {
48430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48431 }
48432 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48433 arg2 = obj1;
48434 arg3 = obj2;
48435 {
48436 PyThreadState* __tstate = wxPyBeginAllowThreads();
48437 (arg1)->_setCallbackInfo(arg2,arg3);
48438 wxPyEndAllowThreads(__tstate);
48439 if (PyErr_Occurred()) SWIG_fail;
48440 }
48441 resultobj = SWIG_Py_Void();
48442 return resultobj;
48443 fail:
48444 return NULL;
48445 }
48446
48447
48448 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48449 PyObject *obj;
48450 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48451 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48452 return SWIG_Py_Void();
48453 }
48454
48455 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48456 return SWIG_Python_InitShadowInstance(args);
48457 }
48458
48459 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48460 PyObject *resultobj = 0;
48461 int arg1 = (int) wxHORIZONTAL ;
48462 wxBoxSizer *result = 0 ;
48463 int val1 ;
48464 int ecode1 = 0 ;
48465 PyObject * obj0 = 0 ;
48466 char * kwnames[] = {
48467 (char *) "orient", NULL
48468 };
48469
48470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48471 if (obj0) {
48472 ecode1 = SWIG_AsVal_int(obj0, &val1);
48473 if (!SWIG_IsOK(ecode1)) {
48474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48475 }
48476 arg1 = static_cast< int >(val1);
48477 }
48478 {
48479 PyThreadState* __tstate = wxPyBeginAllowThreads();
48480 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48481 wxPyEndAllowThreads(__tstate);
48482 if (PyErr_Occurred()) SWIG_fail;
48483 }
48484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48485 return resultobj;
48486 fail:
48487 return NULL;
48488 }
48489
48490
48491 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48492 PyObject *resultobj = 0;
48493 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48494 int result;
48495 void *argp1 = 0 ;
48496 int res1 = 0 ;
48497 PyObject *swig_obj[1] ;
48498
48499 if (!args) SWIG_fail;
48500 swig_obj[0] = args;
48501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48502 if (!SWIG_IsOK(res1)) {
48503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48504 }
48505 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48506 {
48507 PyThreadState* __tstate = wxPyBeginAllowThreads();
48508 result = (int)(arg1)->GetOrientation();
48509 wxPyEndAllowThreads(__tstate);
48510 if (PyErr_Occurred()) SWIG_fail;
48511 }
48512 resultobj = SWIG_From_int(static_cast< int >(result));
48513 return resultobj;
48514 fail:
48515 return NULL;
48516 }
48517
48518
48519 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48520 PyObject *resultobj = 0;
48521 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48522 int arg2 ;
48523 void *argp1 = 0 ;
48524 int res1 = 0 ;
48525 int val2 ;
48526 int ecode2 = 0 ;
48527 PyObject * obj0 = 0 ;
48528 PyObject * obj1 = 0 ;
48529 char * kwnames[] = {
48530 (char *) "self",(char *) "orient", NULL
48531 };
48532
48533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
48534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48535 if (!SWIG_IsOK(res1)) {
48536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48537 }
48538 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48539 ecode2 = SWIG_AsVal_int(obj1, &val2);
48540 if (!SWIG_IsOK(ecode2)) {
48541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
48542 }
48543 arg2 = static_cast< int >(val2);
48544 {
48545 PyThreadState* __tstate = wxPyBeginAllowThreads();
48546 (arg1)->SetOrientation(arg2);
48547 wxPyEndAllowThreads(__tstate);
48548 if (PyErr_Occurred()) SWIG_fail;
48549 }
48550 resultobj = SWIG_Py_Void();
48551 return resultobj;
48552 fail:
48553 return NULL;
48554 }
48555
48556
48557 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48558 PyObject *obj;
48559 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48560 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
48561 return SWIG_Py_Void();
48562 }
48563
48564 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48565 return SWIG_Python_InitShadowInstance(args);
48566 }
48567
48568 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48569 PyObject *resultobj = 0;
48570 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
48571 int arg2 = (int) wxHORIZONTAL ;
48572 wxStaticBoxSizer *result = 0 ;
48573 void *argp1 = 0 ;
48574 int res1 = 0 ;
48575 int val2 ;
48576 int ecode2 = 0 ;
48577 PyObject * obj0 = 0 ;
48578 PyObject * obj1 = 0 ;
48579 char * kwnames[] = {
48580 (char *) "box",(char *) "orient", NULL
48581 };
48582
48583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
48584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
48585 if (!SWIG_IsOK(res1)) {
48586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
48587 }
48588 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
48589 if (obj1) {
48590 ecode2 = SWIG_AsVal_int(obj1, &val2);
48591 if (!SWIG_IsOK(ecode2)) {
48592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48593 }
48594 arg2 = static_cast< int >(val2);
48595 }
48596 {
48597 PyThreadState* __tstate = wxPyBeginAllowThreads();
48598 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48599 wxPyEndAllowThreads(__tstate);
48600 if (PyErr_Occurred()) SWIG_fail;
48601 }
48602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48603 return resultobj;
48604 fail:
48605 return NULL;
48606 }
48607
48608
48609 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48610 PyObject *resultobj = 0;
48611 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48612 wxStaticBox *result = 0 ;
48613 void *argp1 = 0 ;
48614 int res1 = 0 ;
48615 PyObject *swig_obj[1] ;
48616
48617 if (!args) SWIG_fail;
48618 swig_obj[0] = args;
48619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48620 if (!SWIG_IsOK(res1)) {
48621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48622 }
48623 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48624 {
48625 PyThreadState* __tstate = wxPyBeginAllowThreads();
48626 result = (wxStaticBox *)(arg1)->GetStaticBox();
48627 wxPyEndAllowThreads(__tstate);
48628 if (PyErr_Occurred()) SWIG_fail;
48629 }
48630 {
48631 resultobj = wxPyMake_wxObject(result, (bool)0);
48632 }
48633 return resultobj;
48634 fail:
48635 return NULL;
48636 }
48637
48638
48639 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48640 PyObject *obj;
48641 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48642 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48643 return SWIG_Py_Void();
48644 }
48645
48646 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48647 return SWIG_Python_InitShadowInstance(args);
48648 }
48649
48650 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48651 PyObject *resultobj = 0;
48652 int arg1 = (int) 1 ;
48653 int arg2 = (int) 0 ;
48654 int arg3 = (int) 0 ;
48655 int arg4 = (int) 0 ;
48656 wxGridSizer *result = 0 ;
48657 int val1 ;
48658 int ecode1 = 0 ;
48659 int val2 ;
48660 int ecode2 = 0 ;
48661 int val3 ;
48662 int ecode3 = 0 ;
48663 int val4 ;
48664 int ecode4 = 0 ;
48665 PyObject * obj0 = 0 ;
48666 PyObject * obj1 = 0 ;
48667 PyObject * obj2 = 0 ;
48668 PyObject * obj3 = 0 ;
48669 char * kwnames[] = {
48670 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48671 };
48672
48673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48674 if (obj0) {
48675 ecode1 = SWIG_AsVal_int(obj0, &val1);
48676 if (!SWIG_IsOK(ecode1)) {
48677 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48678 }
48679 arg1 = static_cast< int >(val1);
48680 }
48681 if (obj1) {
48682 ecode2 = SWIG_AsVal_int(obj1, &val2);
48683 if (!SWIG_IsOK(ecode2)) {
48684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48685 }
48686 arg2 = static_cast< int >(val2);
48687 }
48688 if (obj2) {
48689 ecode3 = SWIG_AsVal_int(obj2, &val3);
48690 if (!SWIG_IsOK(ecode3)) {
48691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48692 }
48693 arg3 = static_cast< int >(val3);
48694 }
48695 if (obj3) {
48696 ecode4 = SWIG_AsVal_int(obj3, &val4);
48697 if (!SWIG_IsOK(ecode4)) {
48698 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48699 }
48700 arg4 = static_cast< int >(val4);
48701 }
48702 {
48703 PyThreadState* __tstate = wxPyBeginAllowThreads();
48704 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48705 wxPyEndAllowThreads(__tstate);
48706 if (PyErr_Occurred()) SWIG_fail;
48707 }
48708 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48709 return resultobj;
48710 fail:
48711 return NULL;
48712 }
48713
48714
48715 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48716 PyObject *resultobj = 0;
48717 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48718 int arg2 ;
48719 void *argp1 = 0 ;
48720 int res1 = 0 ;
48721 int val2 ;
48722 int ecode2 = 0 ;
48723 PyObject * obj0 = 0 ;
48724 PyObject * obj1 = 0 ;
48725 char * kwnames[] = {
48726 (char *) "self",(char *) "cols", NULL
48727 };
48728
48729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48731 if (!SWIG_IsOK(res1)) {
48732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48733 }
48734 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48735 ecode2 = SWIG_AsVal_int(obj1, &val2);
48736 if (!SWIG_IsOK(ecode2)) {
48737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48738 }
48739 arg2 = static_cast< int >(val2);
48740 {
48741 PyThreadState* __tstate = wxPyBeginAllowThreads();
48742 (arg1)->SetCols(arg2);
48743 wxPyEndAllowThreads(__tstate);
48744 if (PyErr_Occurred()) SWIG_fail;
48745 }
48746 resultobj = SWIG_Py_Void();
48747 return resultobj;
48748 fail:
48749 return NULL;
48750 }
48751
48752
48753 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48754 PyObject *resultobj = 0;
48755 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48756 int arg2 ;
48757 void *argp1 = 0 ;
48758 int res1 = 0 ;
48759 int val2 ;
48760 int ecode2 = 0 ;
48761 PyObject * obj0 = 0 ;
48762 PyObject * obj1 = 0 ;
48763 char * kwnames[] = {
48764 (char *) "self",(char *) "rows", NULL
48765 };
48766
48767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48769 if (!SWIG_IsOK(res1)) {
48770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48771 }
48772 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48773 ecode2 = SWIG_AsVal_int(obj1, &val2);
48774 if (!SWIG_IsOK(ecode2)) {
48775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48776 }
48777 arg2 = static_cast< int >(val2);
48778 {
48779 PyThreadState* __tstate = wxPyBeginAllowThreads();
48780 (arg1)->SetRows(arg2);
48781 wxPyEndAllowThreads(__tstate);
48782 if (PyErr_Occurred()) SWIG_fail;
48783 }
48784 resultobj = SWIG_Py_Void();
48785 return resultobj;
48786 fail:
48787 return NULL;
48788 }
48789
48790
48791 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(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 *) "gap", NULL
48803 };
48804
48805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",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_SetVGap" "', 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_SetVGap" "', expected argument " "2"" of type '" "int""'");
48814 }
48815 arg2 = static_cast< int >(val2);
48816 {
48817 PyThreadState* __tstate = wxPyBeginAllowThreads();
48818 (arg1)->SetVGap(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_SetHGap(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 *) "gap", NULL
48841 };
48842
48843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",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_SetHGap" "', 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_SetHGap" "', expected argument " "2"" of type '" "int""'");
48852 }
48853 arg2 = static_cast< int >(val2);
48854 {
48855 PyThreadState* __tstate = wxPyBeginAllowThreads();
48856 (arg1)->SetHGap(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_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48868 PyObject *resultobj = 0;
48869 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48870 int result;
48871 void *argp1 = 0 ;
48872 int res1 = 0 ;
48873 PyObject *swig_obj[1] ;
48874
48875 if (!args) SWIG_fail;
48876 swig_obj[0] = args;
48877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48878 if (!SWIG_IsOK(res1)) {
48879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48880 }
48881 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48882 {
48883 PyThreadState* __tstate = wxPyBeginAllowThreads();
48884 result = (int)(arg1)->GetCols();
48885 wxPyEndAllowThreads(__tstate);
48886 if (PyErr_Occurred()) SWIG_fail;
48887 }
48888 resultobj = SWIG_From_int(static_cast< int >(result));
48889 return resultobj;
48890 fail:
48891 return NULL;
48892 }
48893
48894
48895 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48896 PyObject *resultobj = 0;
48897 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48898 int result;
48899 void *argp1 = 0 ;
48900 int res1 = 0 ;
48901 PyObject *swig_obj[1] ;
48902
48903 if (!args) SWIG_fail;
48904 swig_obj[0] = args;
48905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48906 if (!SWIG_IsOK(res1)) {
48907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48908 }
48909 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48910 {
48911 PyThreadState* __tstate = wxPyBeginAllowThreads();
48912 result = (int)(arg1)->GetRows();
48913 wxPyEndAllowThreads(__tstate);
48914 if (PyErr_Occurred()) SWIG_fail;
48915 }
48916 resultobj = SWIG_From_int(static_cast< int >(result));
48917 return resultobj;
48918 fail:
48919 return NULL;
48920 }
48921
48922
48923 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48924 PyObject *resultobj = 0;
48925 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48926 int result;
48927 void *argp1 = 0 ;
48928 int res1 = 0 ;
48929 PyObject *swig_obj[1] ;
48930
48931 if (!args) SWIG_fail;
48932 swig_obj[0] = args;
48933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48934 if (!SWIG_IsOK(res1)) {
48935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48936 }
48937 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48938 {
48939 PyThreadState* __tstate = wxPyBeginAllowThreads();
48940 result = (int)(arg1)->GetVGap();
48941 wxPyEndAllowThreads(__tstate);
48942 if (PyErr_Occurred()) SWIG_fail;
48943 }
48944 resultobj = SWIG_From_int(static_cast< int >(result));
48945 return resultobj;
48946 fail:
48947 return NULL;
48948 }
48949
48950
48951 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48952 PyObject *resultobj = 0;
48953 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48954 int result;
48955 void *argp1 = 0 ;
48956 int res1 = 0 ;
48957 PyObject *swig_obj[1] ;
48958
48959 if (!args) SWIG_fail;
48960 swig_obj[0] = args;
48961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48962 if (!SWIG_IsOK(res1)) {
48963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48964 }
48965 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48966 {
48967 PyThreadState* __tstate = wxPyBeginAllowThreads();
48968 result = (int)(arg1)->GetHGap();
48969 wxPyEndAllowThreads(__tstate);
48970 if (PyErr_Occurred()) SWIG_fail;
48971 }
48972 resultobj = SWIG_From_int(static_cast< int >(result));
48973 return resultobj;
48974 fail:
48975 return NULL;
48976 }
48977
48978
48979 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48980 PyObject *obj;
48981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48982 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48983 return SWIG_Py_Void();
48984 }
48985
48986 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48987 return SWIG_Python_InitShadowInstance(args);
48988 }
48989
48990 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48991 PyObject *resultobj = 0;
48992 int arg1 = (int) 1 ;
48993 int arg2 = (int) 0 ;
48994 int arg3 = (int) 0 ;
48995 int arg4 = (int) 0 ;
48996 wxFlexGridSizer *result = 0 ;
48997 int val1 ;
48998 int ecode1 = 0 ;
48999 int val2 ;
49000 int ecode2 = 0 ;
49001 int val3 ;
49002 int ecode3 = 0 ;
49003 int val4 ;
49004 int ecode4 = 0 ;
49005 PyObject * obj0 = 0 ;
49006 PyObject * obj1 = 0 ;
49007 PyObject * obj2 = 0 ;
49008 PyObject * obj3 = 0 ;
49009 char * kwnames[] = {
49010 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49011 };
49012
49013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49014 if (obj0) {
49015 ecode1 = SWIG_AsVal_int(obj0, &val1);
49016 if (!SWIG_IsOK(ecode1)) {
49017 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49018 }
49019 arg1 = static_cast< int >(val1);
49020 }
49021 if (obj1) {
49022 ecode2 = SWIG_AsVal_int(obj1, &val2);
49023 if (!SWIG_IsOK(ecode2)) {
49024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49025 }
49026 arg2 = static_cast< int >(val2);
49027 }
49028 if (obj2) {
49029 ecode3 = SWIG_AsVal_int(obj2, &val3);
49030 if (!SWIG_IsOK(ecode3)) {
49031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49032 }
49033 arg3 = static_cast< int >(val3);
49034 }
49035 if (obj3) {
49036 ecode4 = SWIG_AsVal_int(obj3, &val4);
49037 if (!SWIG_IsOK(ecode4)) {
49038 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49039 }
49040 arg4 = static_cast< int >(val4);
49041 }
49042 {
49043 PyThreadState* __tstate = wxPyBeginAllowThreads();
49044 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49045 wxPyEndAllowThreads(__tstate);
49046 if (PyErr_Occurred()) SWIG_fail;
49047 }
49048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49049 return resultobj;
49050 fail:
49051 return NULL;
49052 }
49053
49054
49055 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49056 PyObject *resultobj = 0;
49057 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49058 size_t arg2 ;
49059 int arg3 = (int) 0 ;
49060 void *argp1 = 0 ;
49061 int res1 = 0 ;
49062 size_t val2 ;
49063 int ecode2 = 0 ;
49064 int val3 ;
49065 int ecode3 = 0 ;
49066 PyObject * obj0 = 0 ;
49067 PyObject * obj1 = 0 ;
49068 PyObject * obj2 = 0 ;
49069 char * kwnames[] = {
49070 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49071 };
49072
49073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49075 if (!SWIG_IsOK(res1)) {
49076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49077 }
49078 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49079 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49080 if (!SWIG_IsOK(ecode2)) {
49081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49082 }
49083 arg2 = static_cast< size_t >(val2);
49084 if (obj2) {
49085 ecode3 = SWIG_AsVal_int(obj2, &val3);
49086 if (!SWIG_IsOK(ecode3)) {
49087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49088 }
49089 arg3 = static_cast< int >(val3);
49090 }
49091 {
49092 PyThreadState* __tstate = wxPyBeginAllowThreads();
49093 (arg1)->AddGrowableRow(arg2,arg3);
49094 wxPyEndAllowThreads(__tstate);
49095 if (PyErr_Occurred()) SWIG_fail;
49096 }
49097 resultobj = SWIG_Py_Void();
49098 return resultobj;
49099 fail:
49100 return NULL;
49101 }
49102
49103
49104 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49105 PyObject *resultobj = 0;
49106 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49107 size_t arg2 ;
49108 void *argp1 = 0 ;
49109 int res1 = 0 ;
49110 size_t val2 ;
49111 int ecode2 = 0 ;
49112 PyObject * obj0 = 0 ;
49113 PyObject * obj1 = 0 ;
49114 char * kwnames[] = {
49115 (char *) "self",(char *) "idx", NULL
49116 };
49117
49118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49120 if (!SWIG_IsOK(res1)) {
49121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49122 }
49123 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49124 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49125 if (!SWIG_IsOK(ecode2)) {
49126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49127 }
49128 arg2 = static_cast< size_t >(val2);
49129 {
49130 PyThreadState* __tstate = wxPyBeginAllowThreads();
49131 (arg1)->RemoveGrowableRow(arg2);
49132 wxPyEndAllowThreads(__tstate);
49133 if (PyErr_Occurred()) SWIG_fail;
49134 }
49135 resultobj = SWIG_Py_Void();
49136 return resultobj;
49137 fail:
49138 return NULL;
49139 }
49140
49141
49142 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49143 PyObject *resultobj = 0;
49144 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49145 size_t arg2 ;
49146 int arg3 = (int) 0 ;
49147 void *argp1 = 0 ;
49148 int res1 = 0 ;
49149 size_t val2 ;
49150 int ecode2 = 0 ;
49151 int val3 ;
49152 int ecode3 = 0 ;
49153 PyObject * obj0 = 0 ;
49154 PyObject * obj1 = 0 ;
49155 PyObject * obj2 = 0 ;
49156 char * kwnames[] = {
49157 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49158 };
49159
49160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49162 if (!SWIG_IsOK(res1)) {
49163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49164 }
49165 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49166 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49167 if (!SWIG_IsOK(ecode2)) {
49168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49169 }
49170 arg2 = static_cast< size_t >(val2);
49171 if (obj2) {
49172 ecode3 = SWIG_AsVal_int(obj2, &val3);
49173 if (!SWIG_IsOK(ecode3)) {
49174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49175 }
49176 arg3 = static_cast< int >(val3);
49177 }
49178 {
49179 PyThreadState* __tstate = wxPyBeginAllowThreads();
49180 (arg1)->AddGrowableCol(arg2,arg3);
49181 wxPyEndAllowThreads(__tstate);
49182 if (PyErr_Occurred()) SWIG_fail;
49183 }
49184 resultobj = SWIG_Py_Void();
49185 return resultobj;
49186 fail:
49187 return NULL;
49188 }
49189
49190
49191 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49192 PyObject *resultobj = 0;
49193 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49194 size_t arg2 ;
49195 void *argp1 = 0 ;
49196 int res1 = 0 ;
49197 size_t val2 ;
49198 int ecode2 = 0 ;
49199 PyObject * obj0 = 0 ;
49200 PyObject * obj1 = 0 ;
49201 char * kwnames[] = {
49202 (char *) "self",(char *) "idx", NULL
49203 };
49204
49205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49207 if (!SWIG_IsOK(res1)) {
49208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49209 }
49210 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49211 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49212 if (!SWIG_IsOK(ecode2)) {
49213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49214 }
49215 arg2 = static_cast< size_t >(val2);
49216 {
49217 PyThreadState* __tstate = wxPyBeginAllowThreads();
49218 (arg1)->RemoveGrowableCol(arg2);
49219 wxPyEndAllowThreads(__tstate);
49220 if (PyErr_Occurred()) SWIG_fail;
49221 }
49222 resultobj = SWIG_Py_Void();
49223 return resultobj;
49224 fail:
49225 return NULL;
49226 }
49227
49228
49229 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49230 PyObject *resultobj = 0;
49231 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49232 int arg2 ;
49233 void *argp1 = 0 ;
49234 int res1 = 0 ;
49235 int val2 ;
49236 int ecode2 = 0 ;
49237 PyObject * obj0 = 0 ;
49238 PyObject * obj1 = 0 ;
49239 char * kwnames[] = {
49240 (char *) "self",(char *) "direction", NULL
49241 };
49242
49243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49245 if (!SWIG_IsOK(res1)) {
49246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49247 }
49248 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49249 ecode2 = SWIG_AsVal_int(obj1, &val2);
49250 if (!SWIG_IsOK(ecode2)) {
49251 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49252 }
49253 arg2 = static_cast< int >(val2);
49254 {
49255 PyThreadState* __tstate = wxPyBeginAllowThreads();
49256 (arg1)->SetFlexibleDirection(arg2);
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_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49268 PyObject *resultobj = 0;
49269 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49270 int result;
49271 void *argp1 = 0 ;
49272 int res1 = 0 ;
49273 PyObject *swig_obj[1] ;
49274
49275 if (!args) SWIG_fail;
49276 swig_obj[0] = args;
49277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49278 if (!SWIG_IsOK(res1)) {
49279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49280 }
49281 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49282 {
49283 PyThreadState* __tstate = wxPyBeginAllowThreads();
49284 result = (int)(arg1)->GetFlexibleDirection();
49285 wxPyEndAllowThreads(__tstate);
49286 if (PyErr_Occurred()) SWIG_fail;
49287 }
49288 resultobj = SWIG_From_int(static_cast< int >(result));
49289 return resultobj;
49290 fail:
49291 return NULL;
49292 }
49293
49294
49295 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49296 PyObject *resultobj = 0;
49297 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49298 wxFlexSizerGrowMode arg2 ;
49299 void *argp1 = 0 ;
49300 int res1 = 0 ;
49301 int val2 ;
49302 int ecode2 = 0 ;
49303 PyObject * obj0 = 0 ;
49304 PyObject * obj1 = 0 ;
49305 char * kwnames[] = {
49306 (char *) "self",(char *) "mode", NULL
49307 };
49308
49309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49311 if (!SWIG_IsOK(res1)) {
49312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49313 }
49314 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49315 ecode2 = SWIG_AsVal_int(obj1, &val2);
49316 if (!SWIG_IsOK(ecode2)) {
49317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49318 }
49319 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49320 {
49321 PyThreadState* __tstate = wxPyBeginAllowThreads();
49322 (arg1)->SetNonFlexibleGrowMode(arg2);
49323 wxPyEndAllowThreads(__tstate);
49324 if (PyErr_Occurred()) SWIG_fail;
49325 }
49326 resultobj = SWIG_Py_Void();
49327 return resultobj;
49328 fail:
49329 return NULL;
49330 }
49331
49332
49333 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49334 PyObject *resultobj = 0;
49335 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49336 wxFlexSizerGrowMode result;
49337 void *argp1 = 0 ;
49338 int res1 = 0 ;
49339 PyObject *swig_obj[1] ;
49340
49341 if (!args) SWIG_fail;
49342 swig_obj[0] = args;
49343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49344 if (!SWIG_IsOK(res1)) {
49345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49346 }
49347 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49348 {
49349 PyThreadState* __tstate = wxPyBeginAllowThreads();
49350 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49351 wxPyEndAllowThreads(__tstate);
49352 if (PyErr_Occurred()) SWIG_fail;
49353 }
49354 resultobj = SWIG_From_int(static_cast< int >(result));
49355 return resultobj;
49356 fail:
49357 return NULL;
49358 }
49359
49360
49361 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49362 PyObject *resultobj = 0;
49363 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49364 wxArrayInt *result = 0 ;
49365 void *argp1 = 0 ;
49366 int res1 = 0 ;
49367 PyObject *swig_obj[1] ;
49368
49369 if (!args) SWIG_fail;
49370 swig_obj[0] = args;
49371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49372 if (!SWIG_IsOK(res1)) {
49373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49374 }
49375 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49376 {
49377 PyThreadState* __tstate = wxPyBeginAllowThreads();
49378 {
49379 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49380 result = (wxArrayInt *) &_result_ref;
49381 }
49382 wxPyEndAllowThreads(__tstate);
49383 if (PyErr_Occurred()) SWIG_fail;
49384 }
49385 {
49386 resultobj = PyList_New(0);
49387 size_t idx;
49388 for (idx = 0; idx < result->GetCount(); idx += 1) {
49389 PyObject* val = PyInt_FromLong( result->Item(idx) );
49390 PyList_Append(resultobj, val);
49391 Py_DECREF(val);
49392 }
49393 }
49394 return resultobj;
49395 fail:
49396 return NULL;
49397 }
49398
49399
49400 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49401 PyObject *resultobj = 0;
49402 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49403 wxArrayInt *result = 0 ;
49404 void *argp1 = 0 ;
49405 int res1 = 0 ;
49406 PyObject *swig_obj[1] ;
49407
49408 if (!args) SWIG_fail;
49409 swig_obj[0] = args;
49410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49411 if (!SWIG_IsOK(res1)) {
49412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49413 }
49414 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49415 {
49416 PyThreadState* __tstate = wxPyBeginAllowThreads();
49417 {
49418 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49419 result = (wxArrayInt *) &_result_ref;
49420 }
49421 wxPyEndAllowThreads(__tstate);
49422 if (PyErr_Occurred()) SWIG_fail;
49423 }
49424 {
49425 resultobj = PyList_New(0);
49426 size_t idx;
49427 for (idx = 0; idx < result->GetCount(); idx += 1) {
49428 PyObject* val = PyInt_FromLong( result->Item(idx) );
49429 PyList_Append(resultobj, val);
49430 Py_DECREF(val);
49431 }
49432 }
49433 return resultobj;
49434 fail:
49435 return NULL;
49436 }
49437
49438
49439 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49440 PyObject *obj;
49441 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49442 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49443 return SWIG_Py_Void();
49444 }
49445
49446 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49447 return SWIG_Python_InitShadowInstance(args);
49448 }
49449
49450 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49451 PyObject *resultobj = 0;
49452 wxStdDialogButtonSizer *result = 0 ;
49453
49454 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49455 {
49456 PyThreadState* __tstate = wxPyBeginAllowThreads();
49457 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49458 wxPyEndAllowThreads(__tstate);
49459 if (PyErr_Occurred()) SWIG_fail;
49460 }
49461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49462 return resultobj;
49463 fail:
49464 return NULL;
49465 }
49466
49467
49468 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49469 PyObject *resultobj = 0;
49470 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49471 wxButton *arg2 = (wxButton *) 0 ;
49472 void *argp1 = 0 ;
49473 int res1 = 0 ;
49474 void *argp2 = 0 ;
49475 int res2 = 0 ;
49476 PyObject * obj0 = 0 ;
49477 PyObject * obj1 = 0 ;
49478 char * kwnames[] = {
49479 (char *) "self",(char *) "button", NULL
49480 };
49481
49482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49484 if (!SWIG_IsOK(res1)) {
49485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49486 }
49487 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49488 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49489 if (!SWIG_IsOK(res2)) {
49490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49491 }
49492 arg2 = reinterpret_cast< wxButton * >(argp2);
49493 {
49494 PyThreadState* __tstate = wxPyBeginAllowThreads();
49495 (arg1)->AddButton(arg2);
49496 wxPyEndAllowThreads(__tstate);
49497 if (PyErr_Occurred()) SWIG_fail;
49498 }
49499 resultobj = SWIG_Py_Void();
49500 return resultobj;
49501 fail:
49502 return NULL;
49503 }
49504
49505
49506 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49507 PyObject *resultobj = 0;
49508 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49509 void *argp1 = 0 ;
49510 int res1 = 0 ;
49511 PyObject *swig_obj[1] ;
49512
49513 if (!args) SWIG_fail;
49514 swig_obj[0] = args;
49515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49516 if (!SWIG_IsOK(res1)) {
49517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49518 }
49519 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49520 {
49521 PyThreadState* __tstate = wxPyBeginAllowThreads();
49522 (arg1)->Realize();
49523 wxPyEndAllowThreads(__tstate);
49524 if (PyErr_Occurred()) SWIG_fail;
49525 }
49526 resultobj = SWIG_Py_Void();
49527 return resultobj;
49528 fail:
49529 return NULL;
49530 }
49531
49532
49533 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49534 PyObject *resultobj = 0;
49535 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49536 wxButton *arg2 = (wxButton *) 0 ;
49537 void *argp1 = 0 ;
49538 int res1 = 0 ;
49539 void *argp2 = 0 ;
49540 int res2 = 0 ;
49541 PyObject * obj0 = 0 ;
49542 PyObject * obj1 = 0 ;
49543 char * kwnames[] = {
49544 (char *) "self",(char *) "button", NULL
49545 };
49546
49547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49549 if (!SWIG_IsOK(res1)) {
49550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49551 }
49552 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49553 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49554 if (!SWIG_IsOK(res2)) {
49555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49556 }
49557 arg2 = reinterpret_cast< wxButton * >(argp2);
49558 {
49559 PyThreadState* __tstate = wxPyBeginAllowThreads();
49560 (arg1)->SetAffirmativeButton(arg2);
49561 wxPyEndAllowThreads(__tstate);
49562 if (PyErr_Occurred()) SWIG_fail;
49563 }
49564 resultobj = SWIG_Py_Void();
49565 return resultobj;
49566 fail:
49567 return NULL;
49568 }
49569
49570
49571 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49572 PyObject *resultobj = 0;
49573 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49574 wxButton *arg2 = (wxButton *) 0 ;
49575 void *argp1 = 0 ;
49576 int res1 = 0 ;
49577 void *argp2 = 0 ;
49578 int res2 = 0 ;
49579 PyObject * obj0 = 0 ;
49580 PyObject * obj1 = 0 ;
49581 char * kwnames[] = {
49582 (char *) "self",(char *) "button", NULL
49583 };
49584
49585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49587 if (!SWIG_IsOK(res1)) {
49588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49589 }
49590 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49591 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49592 if (!SWIG_IsOK(res2)) {
49593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49594 }
49595 arg2 = reinterpret_cast< wxButton * >(argp2);
49596 {
49597 PyThreadState* __tstate = wxPyBeginAllowThreads();
49598 (arg1)->SetNegativeButton(arg2);
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_SetCancelButton(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_SetCancelButton",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_SetCancelButton" "', 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_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49632 }
49633 arg2 = reinterpret_cast< wxButton * >(argp2);
49634 {
49635 PyThreadState* __tstate = wxPyBeginAllowThreads();
49636 (arg1)->SetCancelButton(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_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49648 PyObject *resultobj = 0;
49649 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49650 wxButton *result = 0 ;
49651 void *argp1 = 0 ;
49652 int res1 = 0 ;
49653 PyObject *swig_obj[1] ;
49654
49655 if (!args) SWIG_fail;
49656 swig_obj[0] = args;
49657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49658 if (!SWIG_IsOK(res1)) {
49659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49660 }
49661 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49662 {
49663 PyThreadState* __tstate = wxPyBeginAllowThreads();
49664 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
49665 wxPyEndAllowThreads(__tstate);
49666 if (PyErr_Occurred()) SWIG_fail;
49667 }
49668 {
49669 resultobj = wxPyMake_wxObject(result, (bool)0);
49670 }
49671 return resultobj;
49672 fail:
49673 return NULL;
49674 }
49675
49676
49677 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49678 PyObject *resultobj = 0;
49679 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49680 wxButton *result = 0 ;
49681 void *argp1 = 0 ;
49682 int res1 = 0 ;
49683 PyObject *swig_obj[1] ;
49684
49685 if (!args) SWIG_fail;
49686 swig_obj[0] = args;
49687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49688 if (!SWIG_IsOK(res1)) {
49689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49690 }
49691 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49692 {
49693 PyThreadState* __tstate = wxPyBeginAllowThreads();
49694 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
49695 wxPyEndAllowThreads(__tstate);
49696 if (PyErr_Occurred()) SWIG_fail;
49697 }
49698 {
49699 resultobj = wxPyMake_wxObject(result, (bool)0);
49700 }
49701 return resultobj;
49702 fail:
49703 return NULL;
49704 }
49705
49706
49707 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49708 PyObject *resultobj = 0;
49709 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49710 wxButton *result = 0 ;
49711 void *argp1 = 0 ;
49712 int res1 = 0 ;
49713 PyObject *swig_obj[1] ;
49714
49715 if (!args) SWIG_fail;
49716 swig_obj[0] = args;
49717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49718 if (!SWIG_IsOK(res1)) {
49719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49720 }
49721 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49722 {
49723 PyThreadState* __tstate = wxPyBeginAllowThreads();
49724 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
49725 wxPyEndAllowThreads(__tstate);
49726 if (PyErr_Occurred()) SWIG_fail;
49727 }
49728 {
49729 resultobj = wxPyMake_wxObject(result, (bool)0);
49730 }
49731 return resultobj;
49732 fail:
49733 return NULL;
49734 }
49735
49736
49737 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49738 PyObject *resultobj = 0;
49739 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49740 wxButton *result = 0 ;
49741 void *argp1 = 0 ;
49742 int res1 = 0 ;
49743 PyObject *swig_obj[1] ;
49744
49745 if (!args) SWIG_fail;
49746 swig_obj[0] = args;
49747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49748 if (!SWIG_IsOK(res1)) {
49749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49750 }
49751 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49752 {
49753 PyThreadState* __tstate = wxPyBeginAllowThreads();
49754 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49755 wxPyEndAllowThreads(__tstate);
49756 if (PyErr_Occurred()) SWIG_fail;
49757 }
49758 {
49759 resultobj = wxPyMake_wxObject(result, (bool)0);
49760 }
49761 return resultobj;
49762 fail:
49763 return NULL;
49764 }
49765
49766
49767 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49768 PyObject *resultobj = 0;
49769 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49770 wxButton *result = 0 ;
49771 void *argp1 = 0 ;
49772 int res1 = 0 ;
49773 PyObject *swig_obj[1] ;
49774
49775 if (!args) SWIG_fail;
49776 swig_obj[0] = args;
49777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49778 if (!SWIG_IsOK(res1)) {
49779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49780 }
49781 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49782 {
49783 PyThreadState* __tstate = wxPyBeginAllowThreads();
49784 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49785 wxPyEndAllowThreads(__tstate);
49786 if (PyErr_Occurred()) SWIG_fail;
49787 }
49788 {
49789 resultobj = wxPyMake_wxObject(result, (bool)0);
49790 }
49791 return resultobj;
49792 fail:
49793 return NULL;
49794 }
49795
49796
49797 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49798 PyObject *obj;
49799 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49800 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49801 return SWIG_Py_Void();
49802 }
49803
49804 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49805 return SWIG_Python_InitShadowInstance(args);
49806 }
49807
49808 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49809 PyObject *resultobj = 0;
49810 int arg1 = (int) 0 ;
49811 int arg2 = (int) 0 ;
49812 wxGBPosition *result = 0 ;
49813 int val1 ;
49814 int ecode1 = 0 ;
49815 int val2 ;
49816 int ecode2 = 0 ;
49817 PyObject * obj0 = 0 ;
49818 PyObject * obj1 = 0 ;
49819 char * kwnames[] = {
49820 (char *) "row",(char *) "col", NULL
49821 };
49822
49823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49824 if (obj0) {
49825 ecode1 = SWIG_AsVal_int(obj0, &val1);
49826 if (!SWIG_IsOK(ecode1)) {
49827 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49828 }
49829 arg1 = static_cast< int >(val1);
49830 }
49831 if (obj1) {
49832 ecode2 = SWIG_AsVal_int(obj1, &val2);
49833 if (!SWIG_IsOK(ecode2)) {
49834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49835 }
49836 arg2 = static_cast< int >(val2);
49837 }
49838 {
49839 PyThreadState* __tstate = wxPyBeginAllowThreads();
49840 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49841 wxPyEndAllowThreads(__tstate);
49842 if (PyErr_Occurred()) SWIG_fail;
49843 }
49844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49845 return resultobj;
49846 fail:
49847 return NULL;
49848 }
49849
49850
49851 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49852 PyObject *resultobj = 0;
49853 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49854 void *argp1 = 0 ;
49855 int res1 = 0 ;
49856 PyObject *swig_obj[1] ;
49857
49858 if (!args) SWIG_fail;
49859 swig_obj[0] = args;
49860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49861 if (!SWIG_IsOK(res1)) {
49862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49863 }
49864 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49865 {
49866 PyThreadState* __tstate = wxPyBeginAllowThreads();
49867 delete arg1;
49868
49869 wxPyEndAllowThreads(__tstate);
49870 if (PyErr_Occurred()) SWIG_fail;
49871 }
49872 resultobj = SWIG_Py_Void();
49873 return resultobj;
49874 fail:
49875 return NULL;
49876 }
49877
49878
49879 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49880 PyObject *resultobj = 0;
49881 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49882 int result;
49883 void *argp1 = 0 ;
49884 int res1 = 0 ;
49885 PyObject *swig_obj[1] ;
49886
49887 if (!args) SWIG_fail;
49888 swig_obj[0] = args;
49889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49890 if (!SWIG_IsOK(res1)) {
49891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49892 }
49893 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49894 {
49895 PyThreadState* __tstate = wxPyBeginAllowThreads();
49896 result = (int)((wxGBPosition const *)arg1)->GetRow();
49897 wxPyEndAllowThreads(__tstate);
49898 if (PyErr_Occurred()) SWIG_fail;
49899 }
49900 resultobj = SWIG_From_int(static_cast< int >(result));
49901 return resultobj;
49902 fail:
49903 return NULL;
49904 }
49905
49906
49907 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49908 PyObject *resultobj = 0;
49909 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49910 int result;
49911 void *argp1 = 0 ;
49912 int res1 = 0 ;
49913 PyObject *swig_obj[1] ;
49914
49915 if (!args) SWIG_fail;
49916 swig_obj[0] = args;
49917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49918 if (!SWIG_IsOK(res1)) {
49919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49920 }
49921 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49922 {
49923 PyThreadState* __tstate = wxPyBeginAllowThreads();
49924 result = (int)((wxGBPosition const *)arg1)->GetCol();
49925 wxPyEndAllowThreads(__tstate);
49926 if (PyErr_Occurred()) SWIG_fail;
49927 }
49928 resultobj = SWIG_From_int(static_cast< int >(result));
49929 return resultobj;
49930 fail:
49931 return NULL;
49932 }
49933
49934
49935 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49936 PyObject *resultobj = 0;
49937 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49938 int arg2 ;
49939 void *argp1 = 0 ;
49940 int res1 = 0 ;
49941 int val2 ;
49942 int ecode2 = 0 ;
49943 PyObject * obj0 = 0 ;
49944 PyObject * obj1 = 0 ;
49945 char * kwnames[] = {
49946 (char *) "self",(char *) "row", NULL
49947 };
49948
49949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49951 if (!SWIG_IsOK(res1)) {
49952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49953 }
49954 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49955 ecode2 = SWIG_AsVal_int(obj1, &val2);
49956 if (!SWIG_IsOK(ecode2)) {
49957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49958 }
49959 arg2 = static_cast< int >(val2);
49960 {
49961 PyThreadState* __tstate = wxPyBeginAllowThreads();
49962 (arg1)->SetRow(arg2);
49963 wxPyEndAllowThreads(__tstate);
49964 if (PyErr_Occurred()) SWIG_fail;
49965 }
49966 resultobj = SWIG_Py_Void();
49967 return resultobj;
49968 fail:
49969 return NULL;
49970 }
49971
49972
49973 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49974 PyObject *resultobj = 0;
49975 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49976 int arg2 ;
49977 void *argp1 = 0 ;
49978 int res1 = 0 ;
49979 int val2 ;
49980 int ecode2 = 0 ;
49981 PyObject * obj0 = 0 ;
49982 PyObject * obj1 = 0 ;
49983 char * kwnames[] = {
49984 (char *) "self",(char *) "col", NULL
49985 };
49986
49987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49989 if (!SWIG_IsOK(res1)) {
49990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49991 }
49992 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49993 ecode2 = SWIG_AsVal_int(obj1, &val2);
49994 if (!SWIG_IsOK(ecode2)) {
49995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49996 }
49997 arg2 = static_cast< int >(val2);
49998 {
49999 PyThreadState* __tstate = wxPyBeginAllowThreads();
50000 (arg1)->SetCol(arg2);
50001 wxPyEndAllowThreads(__tstate);
50002 if (PyErr_Occurred()) SWIG_fail;
50003 }
50004 resultobj = SWIG_Py_Void();
50005 return resultobj;
50006 fail:
50007 return NULL;
50008 }
50009
50010
50011 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50012 PyObject *resultobj = 0;
50013 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50014 PyObject *arg2 = (PyObject *) 0 ;
50015 bool result;
50016 void *argp1 = 0 ;
50017 int res1 = 0 ;
50018 PyObject * obj0 = 0 ;
50019 PyObject * obj1 = 0 ;
50020 char * kwnames[] = {
50021 (char *) "self",(char *) "other", NULL
50022 };
50023
50024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50026 if (!SWIG_IsOK(res1)) {
50027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50028 }
50029 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50030 arg2 = obj1;
50031 {
50032 result = (bool)wxGBPosition___eq__(arg1,arg2);
50033 if (PyErr_Occurred()) SWIG_fail;
50034 }
50035 {
50036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50037 }
50038 return resultobj;
50039 fail:
50040 return NULL;
50041 }
50042
50043
50044 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50045 PyObject *resultobj = 0;
50046 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50047 PyObject *arg2 = (PyObject *) 0 ;
50048 bool result;
50049 void *argp1 = 0 ;
50050 int res1 = 0 ;
50051 PyObject * obj0 = 0 ;
50052 PyObject * obj1 = 0 ;
50053 char * kwnames[] = {
50054 (char *) "self",(char *) "other", NULL
50055 };
50056
50057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50059 if (!SWIG_IsOK(res1)) {
50060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50061 }
50062 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50063 arg2 = obj1;
50064 {
50065 result = (bool)wxGBPosition___ne__(arg1,arg2);
50066 if (PyErr_Occurred()) SWIG_fail;
50067 }
50068 {
50069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50070 }
50071 return resultobj;
50072 fail:
50073 return NULL;
50074 }
50075
50076
50077 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50078 PyObject *resultobj = 0;
50079 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50080 int arg2 = (int) 0 ;
50081 int arg3 = (int) 0 ;
50082 void *argp1 = 0 ;
50083 int res1 = 0 ;
50084 int val2 ;
50085 int ecode2 = 0 ;
50086 int val3 ;
50087 int ecode3 = 0 ;
50088 PyObject * obj0 = 0 ;
50089 PyObject * obj1 = 0 ;
50090 PyObject * obj2 = 0 ;
50091 char * kwnames[] = {
50092 (char *) "self",(char *) "row",(char *) "col", NULL
50093 };
50094
50095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50097 if (!SWIG_IsOK(res1)) {
50098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50099 }
50100 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50101 if (obj1) {
50102 ecode2 = SWIG_AsVal_int(obj1, &val2);
50103 if (!SWIG_IsOK(ecode2)) {
50104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50105 }
50106 arg2 = static_cast< int >(val2);
50107 }
50108 if (obj2) {
50109 ecode3 = SWIG_AsVal_int(obj2, &val3);
50110 if (!SWIG_IsOK(ecode3)) {
50111 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50112 }
50113 arg3 = static_cast< int >(val3);
50114 }
50115 {
50116 PyThreadState* __tstate = wxPyBeginAllowThreads();
50117 wxGBPosition_Set(arg1,arg2,arg3);
50118 wxPyEndAllowThreads(__tstate);
50119 if (PyErr_Occurred()) SWIG_fail;
50120 }
50121 resultobj = SWIG_Py_Void();
50122 return resultobj;
50123 fail:
50124 return NULL;
50125 }
50126
50127
50128 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50129 PyObject *resultobj = 0;
50130 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50131 PyObject *result = 0 ;
50132 void *argp1 = 0 ;
50133 int res1 = 0 ;
50134 PyObject *swig_obj[1] ;
50135
50136 if (!args) SWIG_fail;
50137 swig_obj[0] = args;
50138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50139 if (!SWIG_IsOK(res1)) {
50140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50141 }
50142 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50143 {
50144 PyThreadState* __tstate = wxPyBeginAllowThreads();
50145 result = (PyObject *)wxGBPosition_Get(arg1);
50146 wxPyEndAllowThreads(__tstate);
50147 if (PyErr_Occurred()) SWIG_fail;
50148 }
50149 resultobj = result;
50150 return resultobj;
50151 fail:
50152 return NULL;
50153 }
50154
50155
50156 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50157 PyObject *obj;
50158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50159 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50160 return SWIG_Py_Void();
50161 }
50162
50163 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50164 return SWIG_Python_InitShadowInstance(args);
50165 }
50166
50167 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50168 PyObject *resultobj = 0;
50169 int arg1 = (int) 1 ;
50170 int arg2 = (int) 1 ;
50171 wxGBSpan *result = 0 ;
50172 int val1 ;
50173 int ecode1 = 0 ;
50174 int val2 ;
50175 int ecode2 = 0 ;
50176 PyObject * obj0 = 0 ;
50177 PyObject * obj1 = 0 ;
50178 char * kwnames[] = {
50179 (char *) "rowspan",(char *) "colspan", NULL
50180 };
50181
50182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50183 if (obj0) {
50184 ecode1 = SWIG_AsVal_int(obj0, &val1);
50185 if (!SWIG_IsOK(ecode1)) {
50186 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50187 }
50188 arg1 = static_cast< int >(val1);
50189 }
50190 if (obj1) {
50191 ecode2 = SWIG_AsVal_int(obj1, &val2);
50192 if (!SWIG_IsOK(ecode2)) {
50193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50194 }
50195 arg2 = static_cast< int >(val2);
50196 }
50197 {
50198 PyThreadState* __tstate = wxPyBeginAllowThreads();
50199 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50200 wxPyEndAllowThreads(__tstate);
50201 if (PyErr_Occurred()) SWIG_fail;
50202 }
50203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50204 return resultobj;
50205 fail:
50206 return NULL;
50207 }
50208
50209
50210 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50211 PyObject *resultobj = 0;
50212 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50213 void *argp1 = 0 ;
50214 int res1 = 0 ;
50215 PyObject *swig_obj[1] ;
50216
50217 if (!args) SWIG_fail;
50218 swig_obj[0] = args;
50219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50220 if (!SWIG_IsOK(res1)) {
50221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50222 }
50223 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50224 {
50225 PyThreadState* __tstate = wxPyBeginAllowThreads();
50226 delete arg1;
50227
50228 wxPyEndAllowThreads(__tstate);
50229 if (PyErr_Occurred()) SWIG_fail;
50230 }
50231 resultobj = SWIG_Py_Void();
50232 return resultobj;
50233 fail:
50234 return NULL;
50235 }
50236
50237
50238 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50239 PyObject *resultobj = 0;
50240 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50241 int result;
50242 void *argp1 = 0 ;
50243 int res1 = 0 ;
50244 PyObject *swig_obj[1] ;
50245
50246 if (!args) SWIG_fail;
50247 swig_obj[0] = args;
50248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50249 if (!SWIG_IsOK(res1)) {
50250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50251 }
50252 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50253 {
50254 PyThreadState* __tstate = wxPyBeginAllowThreads();
50255 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50256 wxPyEndAllowThreads(__tstate);
50257 if (PyErr_Occurred()) SWIG_fail;
50258 }
50259 resultobj = SWIG_From_int(static_cast< int >(result));
50260 return resultobj;
50261 fail:
50262 return NULL;
50263 }
50264
50265
50266 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50267 PyObject *resultobj = 0;
50268 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50269 int result;
50270 void *argp1 = 0 ;
50271 int res1 = 0 ;
50272 PyObject *swig_obj[1] ;
50273
50274 if (!args) SWIG_fail;
50275 swig_obj[0] = args;
50276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50277 if (!SWIG_IsOK(res1)) {
50278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50279 }
50280 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50281 {
50282 PyThreadState* __tstate = wxPyBeginAllowThreads();
50283 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50284 wxPyEndAllowThreads(__tstate);
50285 if (PyErr_Occurred()) SWIG_fail;
50286 }
50287 resultobj = SWIG_From_int(static_cast< int >(result));
50288 return resultobj;
50289 fail:
50290 return NULL;
50291 }
50292
50293
50294 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50295 PyObject *resultobj = 0;
50296 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50297 int arg2 ;
50298 void *argp1 = 0 ;
50299 int res1 = 0 ;
50300 int val2 ;
50301 int ecode2 = 0 ;
50302 PyObject * obj0 = 0 ;
50303 PyObject * obj1 = 0 ;
50304 char * kwnames[] = {
50305 (char *) "self",(char *) "rowspan", NULL
50306 };
50307
50308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50310 if (!SWIG_IsOK(res1)) {
50311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50312 }
50313 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50314 ecode2 = SWIG_AsVal_int(obj1, &val2);
50315 if (!SWIG_IsOK(ecode2)) {
50316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50317 }
50318 arg2 = static_cast< int >(val2);
50319 {
50320 PyThreadState* __tstate = wxPyBeginAllowThreads();
50321 (arg1)->SetRowspan(arg2);
50322 wxPyEndAllowThreads(__tstate);
50323 if (PyErr_Occurred()) SWIG_fail;
50324 }
50325 resultobj = SWIG_Py_Void();
50326 return resultobj;
50327 fail:
50328 return NULL;
50329 }
50330
50331
50332 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50333 PyObject *resultobj = 0;
50334 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50335 int arg2 ;
50336 void *argp1 = 0 ;
50337 int res1 = 0 ;
50338 int val2 ;
50339 int ecode2 = 0 ;
50340 PyObject * obj0 = 0 ;
50341 PyObject * obj1 = 0 ;
50342 char * kwnames[] = {
50343 (char *) "self",(char *) "colspan", NULL
50344 };
50345
50346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50348 if (!SWIG_IsOK(res1)) {
50349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50350 }
50351 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50352 ecode2 = SWIG_AsVal_int(obj1, &val2);
50353 if (!SWIG_IsOK(ecode2)) {
50354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50355 }
50356 arg2 = static_cast< int >(val2);
50357 {
50358 PyThreadState* __tstate = wxPyBeginAllowThreads();
50359 (arg1)->SetColspan(arg2);
50360 wxPyEndAllowThreads(__tstate);
50361 if (PyErr_Occurred()) SWIG_fail;
50362 }
50363 resultobj = SWIG_Py_Void();
50364 return resultobj;
50365 fail:
50366 return NULL;
50367 }
50368
50369
50370 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50371 PyObject *resultobj = 0;
50372 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50373 PyObject *arg2 = (PyObject *) 0 ;
50374 bool result;
50375 void *argp1 = 0 ;
50376 int res1 = 0 ;
50377 PyObject * obj0 = 0 ;
50378 PyObject * obj1 = 0 ;
50379 char * kwnames[] = {
50380 (char *) "self",(char *) "other", NULL
50381 };
50382
50383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50385 if (!SWIG_IsOK(res1)) {
50386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50387 }
50388 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50389 arg2 = obj1;
50390 {
50391 result = (bool)wxGBSpan___eq__(arg1,arg2);
50392 if (PyErr_Occurred()) SWIG_fail;
50393 }
50394 {
50395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50396 }
50397 return resultobj;
50398 fail:
50399 return NULL;
50400 }
50401
50402
50403 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50404 PyObject *resultobj = 0;
50405 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50406 PyObject *arg2 = (PyObject *) 0 ;
50407 bool result;
50408 void *argp1 = 0 ;
50409 int res1 = 0 ;
50410 PyObject * obj0 = 0 ;
50411 PyObject * obj1 = 0 ;
50412 char * kwnames[] = {
50413 (char *) "self",(char *) "other", NULL
50414 };
50415
50416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50418 if (!SWIG_IsOK(res1)) {
50419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50420 }
50421 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50422 arg2 = obj1;
50423 {
50424 result = (bool)wxGBSpan___ne__(arg1,arg2);
50425 if (PyErr_Occurred()) SWIG_fail;
50426 }
50427 {
50428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50429 }
50430 return resultobj;
50431 fail:
50432 return NULL;
50433 }
50434
50435
50436 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50437 PyObject *resultobj = 0;
50438 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50439 int arg2 = (int) 1 ;
50440 int arg3 = (int) 1 ;
50441 void *argp1 = 0 ;
50442 int res1 = 0 ;
50443 int val2 ;
50444 int ecode2 = 0 ;
50445 int val3 ;
50446 int ecode3 = 0 ;
50447 PyObject * obj0 = 0 ;
50448 PyObject * obj1 = 0 ;
50449 PyObject * obj2 = 0 ;
50450 char * kwnames[] = {
50451 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50452 };
50453
50454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50456 if (!SWIG_IsOK(res1)) {
50457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50458 }
50459 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50460 if (obj1) {
50461 ecode2 = SWIG_AsVal_int(obj1, &val2);
50462 if (!SWIG_IsOK(ecode2)) {
50463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50464 }
50465 arg2 = static_cast< int >(val2);
50466 }
50467 if (obj2) {
50468 ecode3 = SWIG_AsVal_int(obj2, &val3);
50469 if (!SWIG_IsOK(ecode3)) {
50470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50471 }
50472 arg3 = static_cast< int >(val3);
50473 }
50474 {
50475 PyThreadState* __tstate = wxPyBeginAllowThreads();
50476 wxGBSpan_Set(arg1,arg2,arg3);
50477 wxPyEndAllowThreads(__tstate);
50478 if (PyErr_Occurred()) SWIG_fail;
50479 }
50480 resultobj = SWIG_Py_Void();
50481 return resultobj;
50482 fail:
50483 return NULL;
50484 }
50485
50486
50487 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50488 PyObject *resultobj = 0;
50489 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50490 PyObject *result = 0 ;
50491 void *argp1 = 0 ;
50492 int res1 = 0 ;
50493 PyObject *swig_obj[1] ;
50494
50495 if (!args) SWIG_fail;
50496 swig_obj[0] = args;
50497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50498 if (!SWIG_IsOK(res1)) {
50499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50500 }
50501 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50502 {
50503 PyThreadState* __tstate = wxPyBeginAllowThreads();
50504 result = (PyObject *)wxGBSpan_Get(arg1);
50505 wxPyEndAllowThreads(__tstate);
50506 if (PyErr_Occurred()) SWIG_fail;
50507 }
50508 resultobj = result;
50509 return resultobj;
50510 fail:
50511 return NULL;
50512 }
50513
50514
50515 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50516 PyObject *obj;
50517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50518 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50519 return SWIG_Py_Void();
50520 }
50521
50522 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50523 return SWIG_Python_InitShadowInstance(args);
50524 }
50525
50526 SWIGINTERN int DefaultSpan_set(PyObject *) {
50527 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
50528 return 1;
50529 }
50530
50531
50532 SWIGINTERN PyObject *DefaultSpan_get(void) {
50533 PyObject *pyobj = 0;
50534
50535 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
50536 return pyobj;
50537 }
50538
50539
50540 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50541 PyObject *resultobj = 0;
50542 wxGBSizerItem *result = 0 ;
50543
50544 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
50545 {
50546 PyThreadState* __tstate = wxPyBeginAllowThreads();
50547 result = (wxGBSizerItem *)new wxGBSizerItem();
50548 wxPyEndAllowThreads(__tstate);
50549 if (PyErr_Occurred()) SWIG_fail;
50550 }
50551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
50552 return resultobj;
50553 fail:
50554 return NULL;
50555 }
50556
50557
50558 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50559 PyObject *resultobj = 0;
50560 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50561 void *argp1 = 0 ;
50562 int res1 = 0 ;
50563 PyObject *swig_obj[1] ;
50564
50565 if (!args) SWIG_fail;
50566 swig_obj[0] = args;
50567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50568 if (!SWIG_IsOK(res1)) {
50569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50570 }
50571 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50572 {
50573 PyThreadState* __tstate = wxPyBeginAllowThreads();
50574 delete arg1;
50575
50576 wxPyEndAllowThreads(__tstate);
50577 if (PyErr_Occurred()) SWIG_fail;
50578 }
50579 resultobj = SWIG_Py_Void();
50580 return resultobj;
50581 fail:
50582 return NULL;
50583 }
50584
50585
50586 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50587 PyObject *resultobj = 0;
50588 wxWindow *arg1 = (wxWindow *) 0 ;
50589 wxGBPosition *arg2 = 0 ;
50590 wxGBSpan *arg3 = 0 ;
50591 int arg4 ;
50592 int arg5 ;
50593 PyObject *arg6 = (PyObject *) NULL ;
50594 wxGBSizerItem *result = 0 ;
50595 void *argp1 = 0 ;
50596 int res1 = 0 ;
50597 wxGBPosition temp2 ;
50598 wxGBSpan temp3 ;
50599 int val4 ;
50600 int ecode4 = 0 ;
50601 int val5 ;
50602 int ecode5 = 0 ;
50603 PyObject * obj0 = 0 ;
50604 PyObject * obj1 = 0 ;
50605 PyObject * obj2 = 0 ;
50606 PyObject * obj3 = 0 ;
50607 PyObject * obj4 = 0 ;
50608 PyObject * obj5 = 0 ;
50609 char * kwnames[] = {
50610 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50611 };
50612
50613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50615 if (!SWIG_IsOK(res1)) {
50616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50617 }
50618 arg1 = reinterpret_cast< wxWindow * >(argp1);
50619 {
50620 arg2 = &temp2;
50621 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50622 }
50623 {
50624 arg3 = &temp3;
50625 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50626 }
50627 ecode4 = SWIG_AsVal_int(obj3, &val4);
50628 if (!SWIG_IsOK(ecode4)) {
50629 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50630 }
50631 arg4 = static_cast< int >(val4);
50632 ecode5 = SWIG_AsVal_int(obj4, &val5);
50633 if (!SWIG_IsOK(ecode5)) {
50634 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50635 }
50636 arg5 = static_cast< int >(val5);
50637 if (obj5) {
50638 arg6 = obj5;
50639 }
50640 {
50641 PyThreadState* __tstate = wxPyBeginAllowThreads();
50642 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50643 wxPyEndAllowThreads(__tstate);
50644 if (PyErr_Occurred()) SWIG_fail;
50645 }
50646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50647 return resultobj;
50648 fail:
50649 return NULL;
50650 }
50651
50652
50653 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50654 PyObject *resultobj = 0;
50655 wxSizer *arg1 = (wxSizer *) 0 ;
50656 wxGBPosition *arg2 = 0 ;
50657 wxGBSpan *arg3 = 0 ;
50658 int arg4 ;
50659 int arg5 ;
50660 PyObject *arg6 = (PyObject *) NULL ;
50661 wxGBSizerItem *result = 0 ;
50662 int res1 = 0 ;
50663 wxGBPosition temp2 ;
50664 wxGBSpan temp3 ;
50665 int val4 ;
50666 int ecode4 = 0 ;
50667 int val5 ;
50668 int ecode5 = 0 ;
50669 PyObject * obj0 = 0 ;
50670 PyObject * obj1 = 0 ;
50671 PyObject * obj2 = 0 ;
50672 PyObject * obj3 = 0 ;
50673 PyObject * obj4 = 0 ;
50674 PyObject * obj5 = 0 ;
50675 char * kwnames[] = {
50676 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50677 };
50678
50679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50680 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50681 if (!SWIG_IsOK(res1)) {
50682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50683 }
50684 {
50685 arg2 = &temp2;
50686 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50687 }
50688 {
50689 arg3 = &temp3;
50690 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50691 }
50692 ecode4 = SWIG_AsVal_int(obj3, &val4);
50693 if (!SWIG_IsOK(ecode4)) {
50694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50695 }
50696 arg4 = static_cast< int >(val4);
50697 ecode5 = SWIG_AsVal_int(obj4, &val5);
50698 if (!SWIG_IsOK(ecode5)) {
50699 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50700 }
50701 arg5 = static_cast< int >(val5);
50702 if (obj5) {
50703 arg6 = obj5;
50704 }
50705 {
50706 PyThreadState* __tstate = wxPyBeginAllowThreads();
50707 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50708 wxPyEndAllowThreads(__tstate);
50709 if (PyErr_Occurred()) SWIG_fail;
50710 }
50711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50712 return resultobj;
50713 fail:
50714 return NULL;
50715 }
50716
50717
50718 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50719 PyObject *resultobj = 0;
50720 int arg1 ;
50721 int arg2 ;
50722 wxGBPosition *arg3 = 0 ;
50723 wxGBSpan *arg4 = 0 ;
50724 int arg5 ;
50725 int arg6 ;
50726 PyObject *arg7 = (PyObject *) NULL ;
50727 wxGBSizerItem *result = 0 ;
50728 int val1 ;
50729 int ecode1 = 0 ;
50730 int val2 ;
50731 int ecode2 = 0 ;
50732 wxGBPosition temp3 ;
50733 wxGBSpan temp4 ;
50734 int val5 ;
50735 int ecode5 = 0 ;
50736 int val6 ;
50737 int ecode6 = 0 ;
50738 PyObject * obj0 = 0 ;
50739 PyObject * obj1 = 0 ;
50740 PyObject * obj2 = 0 ;
50741 PyObject * obj3 = 0 ;
50742 PyObject * obj4 = 0 ;
50743 PyObject * obj5 = 0 ;
50744 PyObject * obj6 = 0 ;
50745 char * kwnames[] = {
50746 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50747 };
50748
50749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50750 ecode1 = SWIG_AsVal_int(obj0, &val1);
50751 if (!SWIG_IsOK(ecode1)) {
50752 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50753 }
50754 arg1 = static_cast< int >(val1);
50755 ecode2 = SWIG_AsVal_int(obj1, &val2);
50756 if (!SWIG_IsOK(ecode2)) {
50757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50758 }
50759 arg2 = static_cast< int >(val2);
50760 {
50761 arg3 = &temp3;
50762 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50763 }
50764 {
50765 arg4 = &temp4;
50766 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50767 }
50768 ecode5 = SWIG_AsVal_int(obj4, &val5);
50769 if (!SWIG_IsOK(ecode5)) {
50770 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50771 }
50772 arg5 = static_cast< int >(val5);
50773 ecode6 = SWIG_AsVal_int(obj5, &val6);
50774 if (!SWIG_IsOK(ecode6)) {
50775 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50776 }
50777 arg6 = static_cast< int >(val6);
50778 if (obj6) {
50779 arg7 = obj6;
50780 }
50781 {
50782 PyThreadState* __tstate = wxPyBeginAllowThreads();
50783 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
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_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50795 PyObject *resultobj = 0;
50796 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50797 wxGBPosition result;
50798 void *argp1 = 0 ;
50799 int res1 = 0 ;
50800 PyObject *swig_obj[1] ;
50801
50802 if (!args) SWIG_fail;
50803 swig_obj[0] = args;
50804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50805 if (!SWIG_IsOK(res1)) {
50806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50807 }
50808 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50809 {
50810 PyThreadState* __tstate = wxPyBeginAllowThreads();
50811 result = ((wxGBSizerItem const *)arg1)->GetPos();
50812 wxPyEndAllowThreads(__tstate);
50813 if (PyErr_Occurred()) SWIG_fail;
50814 }
50815 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50816 return resultobj;
50817 fail:
50818 return NULL;
50819 }
50820
50821
50822 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50823 PyObject *resultobj = 0;
50824 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50825 wxGBSpan result;
50826 void *argp1 = 0 ;
50827 int res1 = 0 ;
50828 PyObject *swig_obj[1] ;
50829
50830 if (!args) SWIG_fail;
50831 swig_obj[0] = args;
50832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50833 if (!SWIG_IsOK(res1)) {
50834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50835 }
50836 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50837 {
50838 PyThreadState* __tstate = wxPyBeginAllowThreads();
50839 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50840 wxPyEndAllowThreads(__tstate);
50841 if (PyErr_Occurred()) SWIG_fail;
50842 }
50843 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50844 return resultobj;
50845 fail:
50846 return NULL;
50847 }
50848
50849
50850 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50851 PyObject *resultobj = 0;
50852 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50853 wxGBPosition *arg2 = 0 ;
50854 bool result;
50855 void *argp1 = 0 ;
50856 int res1 = 0 ;
50857 wxGBPosition temp2 ;
50858 PyObject * obj0 = 0 ;
50859 PyObject * obj1 = 0 ;
50860 char * kwnames[] = {
50861 (char *) "self",(char *) "pos", NULL
50862 };
50863
50864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50866 if (!SWIG_IsOK(res1)) {
50867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50868 }
50869 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50870 {
50871 arg2 = &temp2;
50872 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50873 }
50874 {
50875 PyThreadState* __tstate = wxPyBeginAllowThreads();
50876 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50877 wxPyEndAllowThreads(__tstate);
50878 if (PyErr_Occurred()) SWIG_fail;
50879 }
50880 {
50881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50882 }
50883 return resultobj;
50884 fail:
50885 return NULL;
50886 }
50887
50888
50889 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50890 PyObject *resultobj = 0;
50891 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50892 wxGBSpan *arg2 = 0 ;
50893 bool result;
50894 void *argp1 = 0 ;
50895 int res1 = 0 ;
50896 wxGBSpan temp2 ;
50897 PyObject * obj0 = 0 ;
50898 PyObject * obj1 = 0 ;
50899 char * kwnames[] = {
50900 (char *) "self",(char *) "span", NULL
50901 };
50902
50903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50905 if (!SWIG_IsOK(res1)) {
50906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50907 }
50908 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50909 {
50910 arg2 = &temp2;
50911 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50912 }
50913 {
50914 PyThreadState* __tstate = wxPyBeginAllowThreads();
50915 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50916 wxPyEndAllowThreads(__tstate);
50917 if (PyErr_Occurred()) SWIG_fail;
50918 }
50919 {
50920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50921 }
50922 return resultobj;
50923 fail:
50924 return NULL;
50925 }
50926
50927
50928 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50929 PyObject *resultobj = 0;
50930 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50931 wxGBSizerItem *arg2 = 0 ;
50932 bool result;
50933 void *argp1 = 0 ;
50934 int res1 = 0 ;
50935 void *argp2 = 0 ;
50936 int res2 = 0 ;
50937 PyObject * obj0 = 0 ;
50938 PyObject * obj1 = 0 ;
50939 char * kwnames[] = {
50940 (char *) "self",(char *) "other", NULL
50941 };
50942
50943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50945 if (!SWIG_IsOK(res1)) {
50946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50947 }
50948 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50949 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50950 if (!SWIG_IsOK(res2)) {
50951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50952 }
50953 if (!argp2) {
50954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50955 }
50956 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50957 {
50958 PyThreadState* __tstate = wxPyBeginAllowThreads();
50959 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50960 wxPyEndAllowThreads(__tstate);
50961 if (PyErr_Occurred()) SWIG_fail;
50962 }
50963 {
50964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50965 }
50966 return resultobj;
50967 fail:
50968 return NULL;
50969 }
50970
50971
50972 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50973 PyObject *resultobj = 0;
50974 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50975 wxGBPosition *arg2 = 0 ;
50976 wxGBSpan *arg3 = 0 ;
50977 bool result;
50978 void *argp1 = 0 ;
50979 int res1 = 0 ;
50980 wxGBPosition temp2 ;
50981 wxGBSpan temp3 ;
50982 PyObject * obj0 = 0 ;
50983 PyObject * obj1 = 0 ;
50984 PyObject * obj2 = 0 ;
50985 char * kwnames[] = {
50986 (char *) "self",(char *) "pos",(char *) "span", NULL
50987 };
50988
50989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50991 if (!SWIG_IsOK(res1)) {
50992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50993 }
50994 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50995 {
50996 arg2 = &temp2;
50997 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50998 }
50999 {
51000 arg3 = &temp3;
51001 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51002 }
51003 {
51004 PyThreadState* __tstate = wxPyBeginAllowThreads();
51005 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51006 wxPyEndAllowThreads(__tstate);
51007 if (PyErr_Occurred()) SWIG_fail;
51008 }
51009 {
51010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51011 }
51012 return resultobj;
51013 fail:
51014 return NULL;
51015 }
51016
51017
51018 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51019 PyObject *resultobj = 0;
51020 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51021 wxGBPosition result;
51022 void *argp1 = 0 ;
51023 int res1 = 0 ;
51024 PyObject *swig_obj[1] ;
51025
51026 if (!args) SWIG_fail;
51027 swig_obj[0] = args;
51028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51029 if (!SWIG_IsOK(res1)) {
51030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51031 }
51032 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51033 {
51034 PyThreadState* __tstate = wxPyBeginAllowThreads();
51035 result = wxGBSizerItem_GetEndPos(arg1);
51036 wxPyEndAllowThreads(__tstate);
51037 if (PyErr_Occurred()) SWIG_fail;
51038 }
51039 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51040 return resultobj;
51041 fail:
51042 return NULL;
51043 }
51044
51045
51046 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51047 PyObject *resultobj = 0;
51048 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51049 wxGridBagSizer *result = 0 ;
51050 void *argp1 = 0 ;
51051 int res1 = 0 ;
51052 PyObject *swig_obj[1] ;
51053
51054 if (!args) SWIG_fail;
51055 swig_obj[0] = args;
51056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51057 if (!SWIG_IsOK(res1)) {
51058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51059 }
51060 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51061 {
51062 PyThreadState* __tstate = wxPyBeginAllowThreads();
51063 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51064 wxPyEndAllowThreads(__tstate);
51065 if (PyErr_Occurred()) SWIG_fail;
51066 }
51067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51068 return resultobj;
51069 fail:
51070 return NULL;
51071 }
51072
51073
51074 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51075 PyObject *resultobj = 0;
51076 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51077 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51078 void *argp1 = 0 ;
51079 int res1 = 0 ;
51080 void *argp2 = 0 ;
51081 int res2 = 0 ;
51082 PyObject * obj0 = 0 ;
51083 PyObject * obj1 = 0 ;
51084 char * kwnames[] = {
51085 (char *) "self",(char *) "sizer", NULL
51086 };
51087
51088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51090 if (!SWIG_IsOK(res1)) {
51091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51092 }
51093 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51094 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51095 if (!SWIG_IsOK(res2)) {
51096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51097 }
51098 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51099 {
51100 PyThreadState* __tstate = wxPyBeginAllowThreads();
51101 (arg1)->SetGBSizer(arg2);
51102 wxPyEndAllowThreads(__tstate);
51103 if (PyErr_Occurred()) SWIG_fail;
51104 }
51105 resultobj = SWIG_Py_Void();
51106 return resultobj;
51107 fail:
51108 return NULL;
51109 }
51110
51111
51112 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51113 PyObject *obj;
51114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51115 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51116 return SWIG_Py_Void();
51117 }
51118
51119 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51120 return SWIG_Python_InitShadowInstance(args);
51121 }
51122
51123 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51124 PyObject *resultobj = 0;
51125 int arg1 = (int) 0 ;
51126 int arg2 = (int) 0 ;
51127 wxGridBagSizer *result = 0 ;
51128 int val1 ;
51129 int ecode1 = 0 ;
51130 int val2 ;
51131 int ecode2 = 0 ;
51132 PyObject * obj0 = 0 ;
51133 PyObject * obj1 = 0 ;
51134 char * kwnames[] = {
51135 (char *) "vgap",(char *) "hgap", NULL
51136 };
51137
51138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51139 if (obj0) {
51140 ecode1 = SWIG_AsVal_int(obj0, &val1);
51141 if (!SWIG_IsOK(ecode1)) {
51142 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51143 }
51144 arg1 = static_cast< int >(val1);
51145 }
51146 if (obj1) {
51147 ecode2 = SWIG_AsVal_int(obj1, &val2);
51148 if (!SWIG_IsOK(ecode2)) {
51149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51150 }
51151 arg2 = static_cast< int >(val2);
51152 }
51153 {
51154 PyThreadState* __tstate = wxPyBeginAllowThreads();
51155 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51156 wxPyEndAllowThreads(__tstate);
51157 if (PyErr_Occurred()) SWIG_fail;
51158 }
51159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51160 return resultobj;
51161 fail:
51162 return NULL;
51163 }
51164
51165
51166 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51167 PyObject *resultobj = 0;
51168 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51169 PyObject *arg2 = (PyObject *) 0 ;
51170 wxGBPosition *arg3 = 0 ;
51171 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51172 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51173 int arg5 = (int) 0 ;
51174 int arg6 = (int) 0 ;
51175 PyObject *arg7 = (PyObject *) NULL ;
51176 wxGBSizerItem *result = 0 ;
51177 void *argp1 = 0 ;
51178 int res1 = 0 ;
51179 wxGBPosition temp3 ;
51180 wxGBSpan temp4 ;
51181 int val5 ;
51182 int ecode5 = 0 ;
51183 int val6 ;
51184 int ecode6 = 0 ;
51185 PyObject * obj0 = 0 ;
51186 PyObject * obj1 = 0 ;
51187 PyObject * obj2 = 0 ;
51188 PyObject * obj3 = 0 ;
51189 PyObject * obj4 = 0 ;
51190 PyObject * obj5 = 0 ;
51191 PyObject * obj6 = 0 ;
51192 char * kwnames[] = {
51193 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51194 };
51195
51196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51198 if (!SWIG_IsOK(res1)) {
51199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51200 }
51201 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51202 arg2 = obj1;
51203 {
51204 arg3 = &temp3;
51205 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51206 }
51207 if (obj3) {
51208 {
51209 arg4 = &temp4;
51210 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51211 }
51212 }
51213 if (obj4) {
51214 ecode5 = SWIG_AsVal_int(obj4, &val5);
51215 if (!SWIG_IsOK(ecode5)) {
51216 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51217 }
51218 arg5 = static_cast< int >(val5);
51219 }
51220 if (obj5) {
51221 ecode6 = SWIG_AsVal_int(obj5, &val6);
51222 if (!SWIG_IsOK(ecode6)) {
51223 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51224 }
51225 arg6 = static_cast< int >(val6);
51226 }
51227 if (obj6) {
51228 arg7 = obj6;
51229 }
51230 {
51231 PyThreadState* __tstate = wxPyBeginAllowThreads();
51232 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51233 wxPyEndAllowThreads(__tstate);
51234 if (PyErr_Occurred()) SWIG_fail;
51235 }
51236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51237 return resultobj;
51238 fail:
51239 return NULL;
51240 }
51241
51242
51243 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51244 PyObject *resultobj = 0;
51245 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51246 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51247 wxGBSizerItem *result = 0 ;
51248 void *argp1 = 0 ;
51249 int res1 = 0 ;
51250 int res2 = 0 ;
51251 PyObject * obj0 = 0 ;
51252 PyObject * obj1 = 0 ;
51253 char * kwnames[] = {
51254 (char *) "self",(char *) "item", NULL
51255 };
51256
51257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51259 if (!SWIG_IsOK(res1)) {
51260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51261 }
51262 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51263 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51264 if (!SWIG_IsOK(res2)) {
51265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51266 }
51267 {
51268 PyThreadState* __tstate = wxPyBeginAllowThreads();
51269 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51270 wxPyEndAllowThreads(__tstate);
51271 if (PyErr_Occurred()) SWIG_fail;
51272 }
51273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51274 return resultobj;
51275 fail:
51276 return NULL;
51277 }
51278
51279
51280 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51281 PyObject *resultobj = 0;
51282 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51283 int arg2 ;
51284 int arg3 ;
51285 wxSize result;
51286 void *argp1 = 0 ;
51287 int res1 = 0 ;
51288 int val2 ;
51289 int ecode2 = 0 ;
51290 int val3 ;
51291 int ecode3 = 0 ;
51292 PyObject * obj0 = 0 ;
51293 PyObject * obj1 = 0 ;
51294 PyObject * obj2 = 0 ;
51295 char * kwnames[] = {
51296 (char *) "self",(char *) "row",(char *) "col", NULL
51297 };
51298
51299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51301 if (!SWIG_IsOK(res1)) {
51302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51303 }
51304 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51305 ecode2 = SWIG_AsVal_int(obj1, &val2);
51306 if (!SWIG_IsOK(ecode2)) {
51307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51308 }
51309 arg2 = static_cast< int >(val2);
51310 ecode3 = SWIG_AsVal_int(obj2, &val3);
51311 if (!SWIG_IsOK(ecode3)) {
51312 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51313 }
51314 arg3 = static_cast< int >(val3);
51315 {
51316 PyThreadState* __tstate = wxPyBeginAllowThreads();
51317 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51318 wxPyEndAllowThreads(__tstate);
51319 if (PyErr_Occurred()) SWIG_fail;
51320 }
51321 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51322 return resultobj;
51323 fail:
51324 return NULL;
51325 }
51326
51327
51328 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51329 PyObject *resultobj = 0;
51330 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51331 wxSize result;
51332 void *argp1 = 0 ;
51333 int res1 = 0 ;
51334 PyObject *swig_obj[1] ;
51335
51336 if (!args) SWIG_fail;
51337 swig_obj[0] = args;
51338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51339 if (!SWIG_IsOK(res1)) {
51340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51341 }
51342 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51343 {
51344 PyThreadState* __tstate = wxPyBeginAllowThreads();
51345 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51346 wxPyEndAllowThreads(__tstate);
51347 if (PyErr_Occurred()) SWIG_fail;
51348 }
51349 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51350 return resultobj;
51351 fail:
51352 return NULL;
51353 }
51354
51355
51356 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51357 PyObject *resultobj = 0;
51358 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51359 wxSize *arg2 = 0 ;
51360 void *argp1 = 0 ;
51361 int res1 = 0 ;
51362 wxSize temp2 ;
51363 PyObject * obj0 = 0 ;
51364 PyObject * obj1 = 0 ;
51365 char * kwnames[] = {
51366 (char *) "self",(char *) "sz", NULL
51367 };
51368
51369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51371 if (!SWIG_IsOK(res1)) {
51372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51373 }
51374 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51375 {
51376 arg2 = &temp2;
51377 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51378 }
51379 {
51380 PyThreadState* __tstate = wxPyBeginAllowThreads();
51381 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51382 wxPyEndAllowThreads(__tstate);
51383 if (PyErr_Occurred()) SWIG_fail;
51384 }
51385 resultobj = SWIG_Py_Void();
51386 return resultobj;
51387 fail:
51388 return NULL;
51389 }
51390
51391
51392 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51393 PyObject *resultobj = 0;
51394 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51395 wxWindow *arg2 = (wxWindow *) 0 ;
51396 wxGBPosition result;
51397 void *argp1 = 0 ;
51398 int res1 = 0 ;
51399 void *argp2 = 0 ;
51400 int res2 = 0 ;
51401
51402 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51404 if (!SWIG_IsOK(res1)) {
51405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51406 }
51407 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51408 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51409 if (!SWIG_IsOK(res2)) {
51410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51411 }
51412 arg2 = reinterpret_cast< wxWindow * >(argp2);
51413 {
51414 PyThreadState* __tstate = wxPyBeginAllowThreads();
51415 result = (arg1)->GetItemPosition(arg2);
51416 wxPyEndAllowThreads(__tstate);
51417 if (PyErr_Occurred()) SWIG_fail;
51418 }
51419 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51420 return resultobj;
51421 fail:
51422 return NULL;
51423 }
51424
51425
51426 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51427 PyObject *resultobj = 0;
51428 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51429 wxSizer *arg2 = (wxSizer *) 0 ;
51430 wxGBPosition result;
51431 void *argp1 = 0 ;
51432 int res1 = 0 ;
51433 void *argp2 = 0 ;
51434 int res2 = 0 ;
51435
51436 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51438 if (!SWIG_IsOK(res1)) {
51439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51440 }
51441 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51442 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51443 if (!SWIG_IsOK(res2)) {
51444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51445 }
51446 arg2 = reinterpret_cast< wxSizer * >(argp2);
51447 {
51448 PyThreadState* __tstate = wxPyBeginAllowThreads();
51449 result = (arg1)->GetItemPosition(arg2);
51450 wxPyEndAllowThreads(__tstate);
51451 if (PyErr_Occurred()) SWIG_fail;
51452 }
51453 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51454 return resultobj;
51455 fail:
51456 return NULL;
51457 }
51458
51459
51460 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51461 PyObject *resultobj = 0;
51462 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51463 size_t arg2 ;
51464 wxGBPosition result;
51465 void *argp1 = 0 ;
51466 int res1 = 0 ;
51467 size_t val2 ;
51468 int ecode2 = 0 ;
51469
51470 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51472 if (!SWIG_IsOK(res1)) {
51473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51474 }
51475 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51476 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51477 if (!SWIG_IsOK(ecode2)) {
51478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51479 }
51480 arg2 = static_cast< size_t >(val2);
51481 {
51482 PyThreadState* __tstate = wxPyBeginAllowThreads();
51483 result = (arg1)->GetItemPosition(arg2);
51484 wxPyEndAllowThreads(__tstate);
51485 if (PyErr_Occurred()) SWIG_fail;
51486 }
51487 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51488 return resultobj;
51489 fail:
51490 return NULL;
51491 }
51492
51493
51494 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51495 int argc;
51496 PyObject *argv[3];
51497
51498 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51499 --argc;
51500 if (argc == 2) {
51501 int _v = 0;
51502 {
51503 void *vptr = 0;
51504 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51505 _v = SWIG_CheckState(res);
51506 }
51507 if (!_v) goto check_1;
51508 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51509 }
51510 check_1:
51511
51512 if (argc == 2) {
51513 int _v = 0;
51514 {
51515 void *vptr = 0;
51516 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51517 _v = SWIG_CheckState(res);
51518 }
51519 if (!_v) goto check_2;
51520 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51521 }
51522 check_2:
51523
51524 if (argc == 2) {
51525 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51526 }
51527
51528 fail:
51529 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
51530 return NULL;
51531 }
51532
51533
51534 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51535 PyObject *resultobj = 0;
51536 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51537 wxWindow *arg2 = (wxWindow *) 0 ;
51538 wxGBPosition *arg3 = 0 ;
51539 bool result;
51540 void *argp1 = 0 ;
51541 int res1 = 0 ;
51542 void *argp2 = 0 ;
51543 int res2 = 0 ;
51544 wxGBPosition temp3 ;
51545
51546 if ((nobjs < 3) || (nobjs > 3)) 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_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51550 }
51551 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51552 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51553 if (!SWIG_IsOK(res2)) {
51554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51555 }
51556 arg2 = reinterpret_cast< wxWindow * >(argp2);
51557 {
51558 arg3 = &temp3;
51559 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51560 }
51561 {
51562 PyThreadState* __tstate = wxPyBeginAllowThreads();
51563 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51564 wxPyEndAllowThreads(__tstate);
51565 if (PyErr_Occurred()) SWIG_fail;
51566 }
51567 {
51568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51569 }
51570 return resultobj;
51571 fail:
51572 return NULL;
51573 }
51574
51575
51576 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51577 PyObject *resultobj = 0;
51578 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51579 wxSizer *arg2 = (wxSizer *) 0 ;
51580 wxGBPosition *arg3 = 0 ;
51581 bool result;
51582 void *argp1 = 0 ;
51583 int res1 = 0 ;
51584 void *argp2 = 0 ;
51585 int res2 = 0 ;
51586 wxGBPosition temp3 ;
51587
51588 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51590 if (!SWIG_IsOK(res1)) {
51591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51592 }
51593 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51594 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51595 if (!SWIG_IsOK(res2)) {
51596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51597 }
51598 arg2 = reinterpret_cast< wxSizer * >(argp2);
51599 {
51600 arg3 = &temp3;
51601 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51602 }
51603 {
51604 PyThreadState* __tstate = wxPyBeginAllowThreads();
51605 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51606 wxPyEndAllowThreads(__tstate);
51607 if (PyErr_Occurred()) SWIG_fail;
51608 }
51609 {
51610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51611 }
51612 return resultobj;
51613 fail:
51614 return NULL;
51615 }
51616
51617
51618 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51619 PyObject *resultobj = 0;
51620 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51621 size_t arg2 ;
51622 wxGBPosition *arg3 = 0 ;
51623 bool result;
51624 void *argp1 = 0 ;
51625 int res1 = 0 ;
51626 size_t val2 ;
51627 int ecode2 = 0 ;
51628 wxGBPosition temp3 ;
51629
51630 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51632 if (!SWIG_IsOK(res1)) {
51633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51634 }
51635 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51636 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51637 if (!SWIG_IsOK(ecode2)) {
51638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51639 }
51640 arg2 = static_cast< size_t >(val2);
51641 {
51642 arg3 = &temp3;
51643 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51644 }
51645 {
51646 PyThreadState* __tstate = wxPyBeginAllowThreads();
51647 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51648 wxPyEndAllowThreads(__tstate);
51649 if (PyErr_Occurred()) SWIG_fail;
51650 }
51651 {
51652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51653 }
51654 return resultobj;
51655 fail:
51656 return NULL;
51657 }
51658
51659
51660 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51661 int argc;
51662 PyObject *argv[4];
51663
51664 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51665 --argc;
51666 if (argc == 3) {
51667 int _v = 0;
51668 {
51669 void *vptr = 0;
51670 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51671 _v = SWIG_CheckState(res);
51672 }
51673 if (!_v) goto check_1;
51674 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51675 }
51676 check_1:
51677
51678 if (argc == 3) {
51679 int _v = 0;
51680 {
51681 void *vptr = 0;
51682 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51683 _v = SWIG_CheckState(res);
51684 }
51685 if (!_v) goto check_2;
51686 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51687 }
51688 check_2:
51689
51690 if (argc == 3) {
51691 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51692 }
51693
51694 fail:
51695 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51696 return NULL;
51697 }
51698
51699
51700 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51701 PyObject *resultobj = 0;
51702 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51703 wxWindow *arg2 = (wxWindow *) 0 ;
51704 wxGBSpan result;
51705 void *argp1 = 0 ;
51706 int res1 = 0 ;
51707 void *argp2 = 0 ;
51708 int res2 = 0 ;
51709
51710 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51712 if (!SWIG_IsOK(res1)) {
51713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51714 }
51715 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51716 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51717 if (!SWIG_IsOK(res2)) {
51718 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51719 }
51720 arg2 = reinterpret_cast< wxWindow * >(argp2);
51721 {
51722 PyThreadState* __tstate = wxPyBeginAllowThreads();
51723 result = (arg1)->GetItemSpan(arg2);
51724 wxPyEndAllowThreads(__tstate);
51725 if (PyErr_Occurred()) SWIG_fail;
51726 }
51727 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51728 return resultobj;
51729 fail:
51730 return NULL;
51731 }
51732
51733
51734 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51735 PyObject *resultobj = 0;
51736 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51737 wxSizer *arg2 = (wxSizer *) 0 ;
51738 wxGBSpan result;
51739 void *argp1 = 0 ;
51740 int res1 = 0 ;
51741 void *argp2 = 0 ;
51742 int res2 = 0 ;
51743
51744 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51746 if (!SWIG_IsOK(res1)) {
51747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51748 }
51749 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51750 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51751 if (!SWIG_IsOK(res2)) {
51752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51753 }
51754 arg2 = reinterpret_cast< wxSizer * >(argp2);
51755 {
51756 PyThreadState* __tstate = wxPyBeginAllowThreads();
51757 result = (arg1)->GetItemSpan(arg2);
51758 wxPyEndAllowThreads(__tstate);
51759 if (PyErr_Occurred()) SWIG_fail;
51760 }
51761 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51762 return resultobj;
51763 fail:
51764 return NULL;
51765 }
51766
51767
51768 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51769 PyObject *resultobj = 0;
51770 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51771 size_t arg2 ;
51772 wxGBSpan result;
51773 void *argp1 = 0 ;
51774 int res1 = 0 ;
51775 size_t val2 ;
51776 int ecode2 = 0 ;
51777
51778 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51780 if (!SWIG_IsOK(res1)) {
51781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51782 }
51783 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51784 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51785 if (!SWIG_IsOK(ecode2)) {
51786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51787 }
51788 arg2 = static_cast< size_t >(val2);
51789 {
51790 PyThreadState* __tstate = wxPyBeginAllowThreads();
51791 result = (arg1)->GetItemSpan(arg2);
51792 wxPyEndAllowThreads(__tstate);
51793 if (PyErr_Occurred()) SWIG_fail;
51794 }
51795 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51796 return resultobj;
51797 fail:
51798 return NULL;
51799 }
51800
51801
51802 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51803 int argc;
51804 PyObject *argv[3];
51805
51806 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51807 --argc;
51808 if (argc == 2) {
51809 int _v = 0;
51810 {
51811 void *vptr = 0;
51812 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51813 _v = SWIG_CheckState(res);
51814 }
51815 if (!_v) goto check_1;
51816 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51817 }
51818 check_1:
51819
51820 if (argc == 2) {
51821 int _v = 0;
51822 {
51823 void *vptr = 0;
51824 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51825 _v = SWIG_CheckState(res);
51826 }
51827 if (!_v) goto check_2;
51828 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51829 }
51830 check_2:
51831
51832 if (argc == 2) {
51833 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51834 }
51835
51836 fail:
51837 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51838 return NULL;
51839 }
51840
51841
51842 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51843 PyObject *resultobj = 0;
51844 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51845 wxWindow *arg2 = (wxWindow *) 0 ;
51846 wxGBSpan *arg3 = 0 ;
51847 bool result;
51848 void *argp1 = 0 ;
51849 int res1 = 0 ;
51850 void *argp2 = 0 ;
51851 int res2 = 0 ;
51852 wxGBSpan temp3 ;
51853
51854 if ((nobjs < 3) || (nobjs > 3)) 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_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51858 }
51859 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51860 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51861 if (!SWIG_IsOK(res2)) {
51862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51863 }
51864 arg2 = reinterpret_cast< wxWindow * >(argp2);
51865 {
51866 arg3 = &temp3;
51867 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51868 }
51869 {
51870 PyThreadState* __tstate = wxPyBeginAllowThreads();
51871 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51872 wxPyEndAllowThreads(__tstate);
51873 if (PyErr_Occurred()) SWIG_fail;
51874 }
51875 {
51876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51877 }
51878 return resultobj;
51879 fail:
51880 return NULL;
51881 }
51882
51883
51884 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51885 PyObject *resultobj = 0;
51886 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51887 wxSizer *arg2 = (wxSizer *) 0 ;
51888 wxGBSpan *arg3 = 0 ;
51889 bool result;
51890 void *argp1 = 0 ;
51891 int res1 = 0 ;
51892 void *argp2 = 0 ;
51893 int res2 = 0 ;
51894 wxGBSpan temp3 ;
51895
51896 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51898 if (!SWIG_IsOK(res1)) {
51899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51900 }
51901 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51902 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51903 if (!SWIG_IsOK(res2)) {
51904 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51905 }
51906 arg2 = reinterpret_cast< wxSizer * >(argp2);
51907 {
51908 arg3 = &temp3;
51909 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51910 }
51911 {
51912 PyThreadState* __tstate = wxPyBeginAllowThreads();
51913 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51914 wxPyEndAllowThreads(__tstate);
51915 if (PyErr_Occurred()) SWIG_fail;
51916 }
51917 {
51918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51919 }
51920 return resultobj;
51921 fail:
51922 return NULL;
51923 }
51924
51925
51926 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51927 PyObject *resultobj = 0;
51928 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51929 size_t arg2 ;
51930 wxGBSpan *arg3 = 0 ;
51931 bool result;
51932 void *argp1 = 0 ;
51933 int res1 = 0 ;
51934 size_t val2 ;
51935 int ecode2 = 0 ;
51936 wxGBSpan temp3 ;
51937
51938 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51940 if (!SWIG_IsOK(res1)) {
51941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51942 }
51943 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51944 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51945 if (!SWIG_IsOK(ecode2)) {
51946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51947 }
51948 arg2 = static_cast< size_t >(val2);
51949 {
51950 arg3 = &temp3;
51951 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51952 }
51953 {
51954 PyThreadState* __tstate = wxPyBeginAllowThreads();
51955 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51956 wxPyEndAllowThreads(__tstate);
51957 if (PyErr_Occurred()) SWIG_fail;
51958 }
51959 {
51960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51961 }
51962 return resultobj;
51963 fail:
51964 return NULL;
51965 }
51966
51967
51968 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51969 int argc;
51970 PyObject *argv[4];
51971
51972 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51973 --argc;
51974 if (argc == 3) {
51975 int _v = 0;
51976 {
51977 void *vptr = 0;
51978 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51979 _v = SWIG_CheckState(res);
51980 }
51981 if (!_v) goto check_1;
51982 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51983 }
51984 check_1:
51985
51986 if (argc == 3) {
51987 int _v = 0;
51988 {
51989 void *vptr = 0;
51990 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51991 _v = SWIG_CheckState(res);
51992 }
51993 if (!_v) goto check_2;
51994 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51995 }
51996 check_2:
51997
51998 if (argc == 3) {
51999 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52000 }
52001
52002 fail:
52003 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52004 return NULL;
52005 }
52006
52007
52008 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52009 PyObject *resultobj = 0;
52010 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52011 wxWindow *arg2 = (wxWindow *) 0 ;
52012 wxGBSizerItem *result = 0 ;
52013 void *argp1 = 0 ;
52014 int res1 = 0 ;
52015 void *argp2 = 0 ;
52016 int res2 = 0 ;
52017
52018 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52020 if (!SWIG_IsOK(res1)) {
52021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52022 }
52023 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52024 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52025 if (!SWIG_IsOK(res2)) {
52026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52027 }
52028 arg2 = reinterpret_cast< wxWindow * >(argp2);
52029 {
52030 PyThreadState* __tstate = wxPyBeginAllowThreads();
52031 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52032 wxPyEndAllowThreads(__tstate);
52033 if (PyErr_Occurred()) SWIG_fail;
52034 }
52035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52036 return resultobj;
52037 fail:
52038 return NULL;
52039 }
52040
52041
52042 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52043 PyObject *resultobj = 0;
52044 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52045 wxSizer *arg2 = (wxSizer *) 0 ;
52046 wxGBSizerItem *result = 0 ;
52047 void *argp1 = 0 ;
52048 int res1 = 0 ;
52049 void *argp2 = 0 ;
52050 int res2 = 0 ;
52051
52052 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52054 if (!SWIG_IsOK(res1)) {
52055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52056 }
52057 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52058 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52059 if (!SWIG_IsOK(res2)) {
52060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52061 }
52062 arg2 = reinterpret_cast< wxSizer * >(argp2);
52063 {
52064 PyThreadState* __tstate = wxPyBeginAllowThreads();
52065 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52066 wxPyEndAllowThreads(__tstate);
52067 if (PyErr_Occurred()) SWIG_fail;
52068 }
52069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52070 return resultobj;
52071 fail:
52072 return NULL;
52073 }
52074
52075
52076 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52077 int argc;
52078 PyObject *argv[3];
52079
52080 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52081 --argc;
52082 if (argc == 2) {
52083 int _v = 0;
52084 {
52085 void *vptr = 0;
52086 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52087 _v = SWIG_CheckState(res);
52088 }
52089 if (!_v) goto check_1;
52090 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52091 }
52092 check_1:
52093
52094 if (argc == 2) {
52095 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52096 }
52097
52098 fail:
52099 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52100 return NULL;
52101 }
52102
52103
52104 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52105 PyObject *resultobj = 0;
52106 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52107 wxGBPosition *arg2 = 0 ;
52108 wxGBSizerItem *result = 0 ;
52109 void *argp1 = 0 ;
52110 int res1 = 0 ;
52111 wxGBPosition temp2 ;
52112 PyObject * obj0 = 0 ;
52113 PyObject * obj1 = 0 ;
52114 char * kwnames[] = {
52115 (char *) "self",(char *) "pos", NULL
52116 };
52117
52118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52120 if (!SWIG_IsOK(res1)) {
52121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52122 }
52123 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52124 {
52125 arg2 = &temp2;
52126 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52127 }
52128 {
52129 PyThreadState* __tstate = wxPyBeginAllowThreads();
52130 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52131 wxPyEndAllowThreads(__tstate);
52132 if (PyErr_Occurred()) SWIG_fail;
52133 }
52134 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52135 return resultobj;
52136 fail:
52137 return NULL;
52138 }
52139
52140
52141 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52142 PyObject *resultobj = 0;
52143 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52144 wxPoint *arg2 = 0 ;
52145 wxGBSizerItem *result = 0 ;
52146 void *argp1 = 0 ;
52147 int res1 = 0 ;
52148 wxPoint temp2 ;
52149 PyObject * obj0 = 0 ;
52150 PyObject * obj1 = 0 ;
52151 char * kwnames[] = {
52152 (char *) "self",(char *) "pt", NULL
52153 };
52154
52155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52157 if (!SWIG_IsOK(res1)) {
52158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52159 }
52160 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52161 {
52162 arg2 = &temp2;
52163 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52164 }
52165 {
52166 PyThreadState* __tstate = wxPyBeginAllowThreads();
52167 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52168 wxPyEndAllowThreads(__tstate);
52169 if (PyErr_Occurred()) SWIG_fail;
52170 }
52171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52172 return resultobj;
52173 fail:
52174 return NULL;
52175 }
52176
52177
52178 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52179 PyObject *resultobj = 0;
52180 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52181 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52182 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52183 bool result;
52184 void *argp1 = 0 ;
52185 int res1 = 0 ;
52186 void *argp2 = 0 ;
52187 int res2 = 0 ;
52188 void *argp3 = 0 ;
52189 int res3 = 0 ;
52190 PyObject * obj0 = 0 ;
52191 PyObject * obj1 = 0 ;
52192 PyObject * obj2 = 0 ;
52193 char * kwnames[] = {
52194 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52195 };
52196
52197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52199 if (!SWIG_IsOK(res1)) {
52200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52201 }
52202 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52203 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52204 if (!SWIG_IsOK(res2)) {
52205 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52206 }
52207 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52208 if (obj2) {
52209 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52210 if (!SWIG_IsOK(res3)) {
52211 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52212 }
52213 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52214 }
52215 {
52216 PyThreadState* __tstate = wxPyBeginAllowThreads();
52217 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52218 wxPyEndAllowThreads(__tstate);
52219 if (PyErr_Occurred()) SWIG_fail;
52220 }
52221 {
52222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52223 }
52224 return resultobj;
52225 fail:
52226 return NULL;
52227 }
52228
52229
52230 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52231 PyObject *resultobj = 0;
52232 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52233 wxGBPosition *arg2 = 0 ;
52234 wxGBSpan *arg3 = 0 ;
52235 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52236 bool result;
52237 void *argp1 = 0 ;
52238 int res1 = 0 ;
52239 wxGBPosition temp2 ;
52240 wxGBSpan temp3 ;
52241 void *argp4 = 0 ;
52242 int res4 = 0 ;
52243 PyObject * obj0 = 0 ;
52244 PyObject * obj1 = 0 ;
52245 PyObject * obj2 = 0 ;
52246 PyObject * obj3 = 0 ;
52247 char * kwnames[] = {
52248 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52249 };
52250
52251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52253 if (!SWIG_IsOK(res1)) {
52254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52255 }
52256 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52257 {
52258 arg2 = &temp2;
52259 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52260 }
52261 {
52262 arg3 = &temp3;
52263 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52264 }
52265 if (obj3) {
52266 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52267 if (!SWIG_IsOK(res4)) {
52268 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52269 }
52270 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52271 }
52272 {
52273 PyThreadState* __tstate = wxPyBeginAllowThreads();
52274 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52275 wxPyEndAllowThreads(__tstate);
52276 if (PyErr_Occurred()) SWIG_fail;
52277 }
52278 {
52279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52280 }
52281 return resultobj;
52282 fail:
52283 return NULL;
52284 }
52285
52286
52287 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52288 PyObject *obj;
52289 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52290 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52291 return SWIG_Py_Void();
52292 }
52293
52294 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52295 return SWIG_Python_InitShadowInstance(args);
52296 }
52297
52298 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52299 PyObject *resultobj = 0;
52300 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52301 wxRelationship arg2 ;
52302 wxWindow *arg3 = (wxWindow *) 0 ;
52303 wxEdge arg4 ;
52304 int arg5 = (int) 0 ;
52305 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52306 void *argp1 = 0 ;
52307 int res1 = 0 ;
52308 int val2 ;
52309 int ecode2 = 0 ;
52310 void *argp3 = 0 ;
52311 int res3 = 0 ;
52312 int val4 ;
52313 int ecode4 = 0 ;
52314 int val5 ;
52315 int ecode5 = 0 ;
52316 int val6 ;
52317 int ecode6 = 0 ;
52318 PyObject * obj0 = 0 ;
52319 PyObject * obj1 = 0 ;
52320 PyObject * obj2 = 0 ;
52321 PyObject * obj3 = 0 ;
52322 PyObject * obj4 = 0 ;
52323 PyObject * obj5 = 0 ;
52324 char * kwnames[] = {
52325 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52326 };
52327
52328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52330 if (!SWIG_IsOK(res1)) {
52331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52332 }
52333 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52334 ecode2 = SWIG_AsVal_int(obj1, &val2);
52335 if (!SWIG_IsOK(ecode2)) {
52336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52337 }
52338 arg2 = static_cast< wxRelationship >(val2);
52339 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52340 if (!SWIG_IsOK(res3)) {
52341 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52342 }
52343 arg3 = reinterpret_cast< wxWindow * >(argp3);
52344 ecode4 = SWIG_AsVal_int(obj3, &val4);
52345 if (!SWIG_IsOK(ecode4)) {
52346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52347 }
52348 arg4 = static_cast< wxEdge >(val4);
52349 if (obj4) {
52350 ecode5 = SWIG_AsVal_int(obj4, &val5);
52351 if (!SWIG_IsOK(ecode5)) {
52352 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52353 }
52354 arg5 = static_cast< int >(val5);
52355 }
52356 if (obj5) {
52357 ecode6 = SWIG_AsVal_int(obj5, &val6);
52358 if (!SWIG_IsOK(ecode6)) {
52359 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52360 }
52361 arg6 = static_cast< int >(val6);
52362 }
52363 {
52364 PyThreadState* __tstate = wxPyBeginAllowThreads();
52365 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52366 wxPyEndAllowThreads(__tstate);
52367 if (PyErr_Occurred()) SWIG_fail;
52368 }
52369 resultobj = SWIG_Py_Void();
52370 return resultobj;
52371 fail:
52372 return NULL;
52373 }
52374
52375
52376 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52377 PyObject *resultobj = 0;
52378 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52379 wxWindow *arg2 = (wxWindow *) 0 ;
52380 int arg3 = (int) 0 ;
52381 void *argp1 = 0 ;
52382 int res1 = 0 ;
52383 void *argp2 = 0 ;
52384 int res2 = 0 ;
52385 int val3 ;
52386 int ecode3 = 0 ;
52387 PyObject * obj0 = 0 ;
52388 PyObject * obj1 = 0 ;
52389 PyObject * obj2 = 0 ;
52390 char * kwnames[] = {
52391 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52392 };
52393
52394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52396 if (!SWIG_IsOK(res1)) {
52397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52398 }
52399 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52401 if (!SWIG_IsOK(res2)) {
52402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52403 }
52404 arg2 = reinterpret_cast< wxWindow * >(argp2);
52405 if (obj2) {
52406 ecode3 = SWIG_AsVal_int(obj2, &val3);
52407 if (!SWIG_IsOK(ecode3)) {
52408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52409 }
52410 arg3 = static_cast< int >(val3);
52411 }
52412 {
52413 PyThreadState* __tstate = wxPyBeginAllowThreads();
52414 (arg1)->LeftOf(arg2,arg3);
52415 wxPyEndAllowThreads(__tstate);
52416 if (PyErr_Occurred()) SWIG_fail;
52417 }
52418 resultobj = SWIG_Py_Void();
52419 return resultobj;
52420 fail:
52421 return NULL;
52422 }
52423
52424
52425 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52426 PyObject *resultobj = 0;
52427 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52428 wxWindow *arg2 = (wxWindow *) 0 ;
52429 int arg3 = (int) 0 ;
52430 void *argp1 = 0 ;
52431 int res1 = 0 ;
52432 void *argp2 = 0 ;
52433 int res2 = 0 ;
52434 int val3 ;
52435 int ecode3 = 0 ;
52436 PyObject * obj0 = 0 ;
52437 PyObject * obj1 = 0 ;
52438 PyObject * obj2 = 0 ;
52439 char * kwnames[] = {
52440 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52441 };
52442
52443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52445 if (!SWIG_IsOK(res1)) {
52446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52447 }
52448 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52450 if (!SWIG_IsOK(res2)) {
52451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52452 }
52453 arg2 = reinterpret_cast< wxWindow * >(argp2);
52454 if (obj2) {
52455 ecode3 = SWIG_AsVal_int(obj2, &val3);
52456 if (!SWIG_IsOK(ecode3)) {
52457 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52458 }
52459 arg3 = static_cast< int >(val3);
52460 }
52461 {
52462 PyThreadState* __tstate = wxPyBeginAllowThreads();
52463 (arg1)->RightOf(arg2,arg3);
52464 wxPyEndAllowThreads(__tstate);
52465 if (PyErr_Occurred()) SWIG_fail;
52466 }
52467 resultobj = SWIG_Py_Void();
52468 return resultobj;
52469 fail:
52470 return NULL;
52471 }
52472
52473
52474 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52475 PyObject *resultobj = 0;
52476 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52477 wxWindow *arg2 = (wxWindow *) 0 ;
52478 int arg3 = (int) 0 ;
52479 void *argp1 = 0 ;
52480 int res1 = 0 ;
52481 void *argp2 = 0 ;
52482 int res2 = 0 ;
52483 int val3 ;
52484 int ecode3 = 0 ;
52485 PyObject * obj0 = 0 ;
52486 PyObject * obj1 = 0 ;
52487 PyObject * obj2 = 0 ;
52488 char * kwnames[] = {
52489 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52490 };
52491
52492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52494 if (!SWIG_IsOK(res1)) {
52495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52496 }
52497 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52498 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52499 if (!SWIG_IsOK(res2)) {
52500 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52501 }
52502 arg2 = reinterpret_cast< wxWindow * >(argp2);
52503 if (obj2) {
52504 ecode3 = SWIG_AsVal_int(obj2, &val3);
52505 if (!SWIG_IsOK(ecode3)) {
52506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52507 }
52508 arg3 = static_cast< int >(val3);
52509 }
52510 {
52511 PyThreadState* __tstate = wxPyBeginAllowThreads();
52512 (arg1)->Above(arg2,arg3);
52513 wxPyEndAllowThreads(__tstate);
52514 if (PyErr_Occurred()) SWIG_fail;
52515 }
52516 resultobj = SWIG_Py_Void();
52517 return resultobj;
52518 fail:
52519 return NULL;
52520 }
52521
52522
52523 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52524 PyObject *resultobj = 0;
52525 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52526 wxWindow *arg2 = (wxWindow *) 0 ;
52527 int arg3 = (int) 0 ;
52528 void *argp1 = 0 ;
52529 int res1 = 0 ;
52530 void *argp2 = 0 ;
52531 int res2 = 0 ;
52532 int val3 ;
52533 int ecode3 = 0 ;
52534 PyObject * obj0 = 0 ;
52535 PyObject * obj1 = 0 ;
52536 PyObject * obj2 = 0 ;
52537 char * kwnames[] = {
52538 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52539 };
52540
52541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52543 if (!SWIG_IsOK(res1)) {
52544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52545 }
52546 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52547 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52548 if (!SWIG_IsOK(res2)) {
52549 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
52550 }
52551 arg2 = reinterpret_cast< wxWindow * >(argp2);
52552 if (obj2) {
52553 ecode3 = SWIG_AsVal_int(obj2, &val3);
52554 if (!SWIG_IsOK(ecode3)) {
52555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
52556 }
52557 arg3 = static_cast< int >(val3);
52558 }
52559 {
52560 PyThreadState* __tstate = wxPyBeginAllowThreads();
52561 (arg1)->Below(arg2,arg3);
52562 wxPyEndAllowThreads(__tstate);
52563 if (PyErr_Occurred()) SWIG_fail;
52564 }
52565 resultobj = SWIG_Py_Void();
52566 return resultobj;
52567 fail:
52568 return NULL;
52569 }
52570
52571
52572 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52573 PyObject *resultobj = 0;
52574 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52575 wxWindow *arg2 = (wxWindow *) 0 ;
52576 wxEdge arg3 ;
52577 int arg4 = (int) 0 ;
52578 void *argp1 = 0 ;
52579 int res1 = 0 ;
52580 void *argp2 = 0 ;
52581 int res2 = 0 ;
52582 int val3 ;
52583 int ecode3 = 0 ;
52584 int val4 ;
52585 int ecode4 = 0 ;
52586 PyObject * obj0 = 0 ;
52587 PyObject * obj1 = 0 ;
52588 PyObject * obj2 = 0 ;
52589 PyObject * obj3 = 0 ;
52590 char * kwnames[] = {
52591 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52592 };
52593
52594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52596 if (!SWIG_IsOK(res1)) {
52597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52598 }
52599 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52601 if (!SWIG_IsOK(res2)) {
52602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52603 }
52604 arg2 = reinterpret_cast< wxWindow * >(argp2);
52605 ecode3 = SWIG_AsVal_int(obj2, &val3);
52606 if (!SWIG_IsOK(ecode3)) {
52607 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52608 }
52609 arg3 = static_cast< wxEdge >(val3);
52610 if (obj3) {
52611 ecode4 = SWIG_AsVal_int(obj3, &val4);
52612 if (!SWIG_IsOK(ecode4)) {
52613 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52614 }
52615 arg4 = static_cast< int >(val4);
52616 }
52617 {
52618 PyThreadState* __tstate = wxPyBeginAllowThreads();
52619 (arg1)->SameAs(arg2,arg3,arg4);
52620 wxPyEndAllowThreads(__tstate);
52621 if (PyErr_Occurred()) SWIG_fail;
52622 }
52623 resultobj = SWIG_Py_Void();
52624 return resultobj;
52625 fail:
52626 return NULL;
52627 }
52628
52629
52630 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52631 PyObject *resultobj = 0;
52632 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52633 wxWindow *arg2 = (wxWindow *) 0 ;
52634 wxEdge arg3 ;
52635 int arg4 ;
52636 void *argp1 = 0 ;
52637 int res1 = 0 ;
52638 void *argp2 = 0 ;
52639 int res2 = 0 ;
52640 int val3 ;
52641 int ecode3 = 0 ;
52642 int val4 ;
52643 int ecode4 = 0 ;
52644 PyObject * obj0 = 0 ;
52645 PyObject * obj1 = 0 ;
52646 PyObject * obj2 = 0 ;
52647 PyObject * obj3 = 0 ;
52648 char * kwnames[] = {
52649 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52650 };
52651
52652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52654 if (!SWIG_IsOK(res1)) {
52655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52656 }
52657 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52658 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52659 if (!SWIG_IsOK(res2)) {
52660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52661 }
52662 arg2 = reinterpret_cast< wxWindow * >(argp2);
52663 ecode3 = SWIG_AsVal_int(obj2, &val3);
52664 if (!SWIG_IsOK(ecode3)) {
52665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52666 }
52667 arg3 = static_cast< wxEdge >(val3);
52668 ecode4 = SWIG_AsVal_int(obj3, &val4);
52669 if (!SWIG_IsOK(ecode4)) {
52670 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52671 }
52672 arg4 = static_cast< int >(val4);
52673 {
52674 PyThreadState* __tstate = wxPyBeginAllowThreads();
52675 (arg1)->PercentOf(arg2,arg3,arg4);
52676 wxPyEndAllowThreads(__tstate);
52677 if (PyErr_Occurred()) SWIG_fail;
52678 }
52679 resultobj = SWIG_Py_Void();
52680 return resultobj;
52681 fail:
52682 return NULL;
52683 }
52684
52685
52686 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52687 PyObject *resultobj = 0;
52688 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52689 int arg2 ;
52690 void *argp1 = 0 ;
52691 int res1 = 0 ;
52692 int val2 ;
52693 int ecode2 = 0 ;
52694 PyObject * obj0 = 0 ;
52695 PyObject * obj1 = 0 ;
52696 char * kwnames[] = {
52697 (char *) "self",(char *) "val", NULL
52698 };
52699
52700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52702 if (!SWIG_IsOK(res1)) {
52703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52704 }
52705 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52706 ecode2 = SWIG_AsVal_int(obj1, &val2);
52707 if (!SWIG_IsOK(ecode2)) {
52708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52709 }
52710 arg2 = static_cast< int >(val2);
52711 {
52712 PyThreadState* __tstate = wxPyBeginAllowThreads();
52713 (arg1)->Absolute(arg2);
52714 wxPyEndAllowThreads(__tstate);
52715 if (PyErr_Occurred()) SWIG_fail;
52716 }
52717 resultobj = SWIG_Py_Void();
52718 return resultobj;
52719 fail:
52720 return NULL;
52721 }
52722
52723
52724 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52725 PyObject *resultobj = 0;
52726 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52727 void *argp1 = 0 ;
52728 int res1 = 0 ;
52729 PyObject *swig_obj[1] ;
52730
52731 if (!args) SWIG_fail;
52732 swig_obj[0] = args;
52733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52734 if (!SWIG_IsOK(res1)) {
52735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52736 }
52737 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52738 {
52739 PyThreadState* __tstate = wxPyBeginAllowThreads();
52740 (arg1)->Unconstrained();
52741 wxPyEndAllowThreads(__tstate);
52742 if (PyErr_Occurred()) SWIG_fail;
52743 }
52744 resultobj = SWIG_Py_Void();
52745 return resultobj;
52746 fail:
52747 return NULL;
52748 }
52749
52750
52751 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52752 PyObject *resultobj = 0;
52753 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52754 void *argp1 = 0 ;
52755 int res1 = 0 ;
52756 PyObject *swig_obj[1] ;
52757
52758 if (!args) SWIG_fail;
52759 swig_obj[0] = args;
52760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52761 if (!SWIG_IsOK(res1)) {
52762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52763 }
52764 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52765 {
52766 PyThreadState* __tstate = wxPyBeginAllowThreads();
52767 (arg1)->AsIs();
52768 wxPyEndAllowThreads(__tstate);
52769 if (PyErr_Occurred()) SWIG_fail;
52770 }
52771 resultobj = SWIG_Py_Void();
52772 return resultobj;
52773 fail:
52774 return NULL;
52775 }
52776
52777
52778 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52779 PyObject *resultobj = 0;
52780 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52781 wxWindow *result = 0 ;
52782 void *argp1 = 0 ;
52783 int res1 = 0 ;
52784 PyObject *swig_obj[1] ;
52785
52786 if (!args) SWIG_fail;
52787 swig_obj[0] = args;
52788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52789 if (!SWIG_IsOK(res1)) {
52790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52791 }
52792 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52793 {
52794 PyThreadState* __tstate = wxPyBeginAllowThreads();
52795 result = (wxWindow *)(arg1)->GetOtherWindow();
52796 wxPyEndAllowThreads(__tstate);
52797 if (PyErr_Occurred()) SWIG_fail;
52798 }
52799 {
52800 resultobj = wxPyMake_wxObject(result, 0);
52801 }
52802 return resultobj;
52803 fail:
52804 return NULL;
52805 }
52806
52807
52808 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52809 PyObject *resultobj = 0;
52810 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52811 wxEdge result;
52812 void *argp1 = 0 ;
52813 int res1 = 0 ;
52814 PyObject *swig_obj[1] ;
52815
52816 if (!args) SWIG_fail;
52817 swig_obj[0] = args;
52818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52819 if (!SWIG_IsOK(res1)) {
52820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52821 }
52822 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52823 {
52824 PyThreadState* __tstate = wxPyBeginAllowThreads();
52825 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52826 wxPyEndAllowThreads(__tstate);
52827 if (PyErr_Occurred()) SWIG_fail;
52828 }
52829 resultobj = SWIG_From_int(static_cast< int >(result));
52830 return resultobj;
52831 fail:
52832 return NULL;
52833 }
52834
52835
52836 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52837 PyObject *resultobj = 0;
52838 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52839 wxEdge arg2 ;
52840 void *argp1 = 0 ;
52841 int res1 = 0 ;
52842 int val2 ;
52843 int ecode2 = 0 ;
52844 PyObject * obj0 = 0 ;
52845 PyObject * obj1 = 0 ;
52846 char * kwnames[] = {
52847 (char *) "self",(char *) "which", NULL
52848 };
52849
52850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52852 if (!SWIG_IsOK(res1)) {
52853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52854 }
52855 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52856 ecode2 = SWIG_AsVal_int(obj1, &val2);
52857 if (!SWIG_IsOK(ecode2)) {
52858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52859 }
52860 arg2 = static_cast< wxEdge >(val2);
52861 {
52862 PyThreadState* __tstate = wxPyBeginAllowThreads();
52863 (arg1)->SetEdge(arg2);
52864 wxPyEndAllowThreads(__tstate);
52865 if (PyErr_Occurred()) SWIG_fail;
52866 }
52867 resultobj = SWIG_Py_Void();
52868 return resultobj;
52869 fail:
52870 return NULL;
52871 }
52872
52873
52874 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52875 PyObject *resultobj = 0;
52876 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52877 int arg2 ;
52878 void *argp1 = 0 ;
52879 int res1 = 0 ;
52880 int val2 ;
52881 int ecode2 = 0 ;
52882 PyObject * obj0 = 0 ;
52883 PyObject * obj1 = 0 ;
52884 char * kwnames[] = {
52885 (char *) "self",(char *) "v", NULL
52886 };
52887
52888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52890 if (!SWIG_IsOK(res1)) {
52891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52892 }
52893 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52894 ecode2 = SWIG_AsVal_int(obj1, &val2);
52895 if (!SWIG_IsOK(ecode2)) {
52896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52897 }
52898 arg2 = static_cast< int >(val2);
52899 {
52900 PyThreadState* __tstate = wxPyBeginAllowThreads();
52901 (arg1)->SetValue(arg2);
52902 wxPyEndAllowThreads(__tstate);
52903 if (PyErr_Occurred()) SWIG_fail;
52904 }
52905 resultobj = SWIG_Py_Void();
52906 return resultobj;
52907 fail:
52908 return NULL;
52909 }
52910
52911
52912 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52913 PyObject *resultobj = 0;
52914 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52915 int result;
52916 void *argp1 = 0 ;
52917 int res1 = 0 ;
52918 PyObject *swig_obj[1] ;
52919
52920 if (!args) SWIG_fail;
52921 swig_obj[0] = args;
52922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52923 if (!SWIG_IsOK(res1)) {
52924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52925 }
52926 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52927 {
52928 PyThreadState* __tstate = wxPyBeginAllowThreads();
52929 result = (int)(arg1)->GetMargin();
52930 wxPyEndAllowThreads(__tstate);
52931 if (PyErr_Occurred()) SWIG_fail;
52932 }
52933 resultobj = SWIG_From_int(static_cast< int >(result));
52934 return resultobj;
52935 fail:
52936 return NULL;
52937 }
52938
52939
52940 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52941 PyObject *resultobj = 0;
52942 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52943 int arg2 ;
52944 void *argp1 = 0 ;
52945 int res1 = 0 ;
52946 int val2 ;
52947 int ecode2 = 0 ;
52948 PyObject * obj0 = 0 ;
52949 PyObject * obj1 = 0 ;
52950 char * kwnames[] = {
52951 (char *) "self",(char *) "m", NULL
52952 };
52953
52954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52956 if (!SWIG_IsOK(res1)) {
52957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52958 }
52959 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52960 ecode2 = SWIG_AsVal_int(obj1, &val2);
52961 if (!SWIG_IsOK(ecode2)) {
52962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52963 }
52964 arg2 = static_cast< int >(val2);
52965 {
52966 PyThreadState* __tstate = wxPyBeginAllowThreads();
52967 (arg1)->SetMargin(arg2);
52968 wxPyEndAllowThreads(__tstate);
52969 if (PyErr_Occurred()) SWIG_fail;
52970 }
52971 resultobj = SWIG_Py_Void();
52972 return resultobj;
52973 fail:
52974 return NULL;
52975 }
52976
52977
52978 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52979 PyObject *resultobj = 0;
52980 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52981 int result;
52982 void *argp1 = 0 ;
52983 int res1 = 0 ;
52984 PyObject *swig_obj[1] ;
52985
52986 if (!args) SWIG_fail;
52987 swig_obj[0] = args;
52988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52989 if (!SWIG_IsOK(res1)) {
52990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52991 }
52992 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52993 {
52994 PyThreadState* __tstate = wxPyBeginAllowThreads();
52995 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52996 wxPyEndAllowThreads(__tstate);
52997 if (PyErr_Occurred()) SWIG_fail;
52998 }
52999 resultobj = SWIG_From_int(static_cast< int >(result));
53000 return resultobj;
53001 fail:
53002 return NULL;
53003 }
53004
53005
53006 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53007 PyObject *resultobj = 0;
53008 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53009 int result;
53010 void *argp1 = 0 ;
53011 int res1 = 0 ;
53012 PyObject *swig_obj[1] ;
53013
53014 if (!args) SWIG_fail;
53015 swig_obj[0] = args;
53016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53017 if (!SWIG_IsOK(res1)) {
53018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53019 }
53020 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53021 {
53022 PyThreadState* __tstate = wxPyBeginAllowThreads();
53023 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53024 wxPyEndAllowThreads(__tstate);
53025 if (PyErr_Occurred()) SWIG_fail;
53026 }
53027 resultobj = SWIG_From_int(static_cast< int >(result));
53028 return resultobj;
53029 fail:
53030 return NULL;
53031 }
53032
53033
53034 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53035 PyObject *resultobj = 0;
53036 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53037 int result;
53038 void *argp1 = 0 ;
53039 int res1 = 0 ;
53040 PyObject *swig_obj[1] ;
53041
53042 if (!args) SWIG_fail;
53043 swig_obj[0] = args;
53044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53045 if (!SWIG_IsOK(res1)) {
53046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53047 }
53048 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53049 {
53050 PyThreadState* __tstate = wxPyBeginAllowThreads();
53051 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53052 wxPyEndAllowThreads(__tstate);
53053 if (PyErr_Occurred()) SWIG_fail;
53054 }
53055 resultobj = SWIG_From_int(static_cast< int >(result));
53056 return resultobj;
53057 fail:
53058 return NULL;
53059 }
53060
53061
53062 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53063 PyObject *resultobj = 0;
53064 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53065 bool result;
53066 void *argp1 = 0 ;
53067 int res1 = 0 ;
53068 PyObject *swig_obj[1] ;
53069
53070 if (!args) SWIG_fail;
53071 swig_obj[0] = args;
53072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53073 if (!SWIG_IsOK(res1)) {
53074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53075 }
53076 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53077 {
53078 PyThreadState* __tstate = wxPyBeginAllowThreads();
53079 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53080 wxPyEndAllowThreads(__tstate);
53081 if (PyErr_Occurred()) SWIG_fail;
53082 }
53083 {
53084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53085 }
53086 return resultobj;
53087 fail:
53088 return NULL;
53089 }
53090
53091
53092 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53093 PyObject *resultobj = 0;
53094 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53095 bool arg2 ;
53096 void *argp1 = 0 ;
53097 int res1 = 0 ;
53098 bool val2 ;
53099 int ecode2 = 0 ;
53100 PyObject * obj0 = 0 ;
53101 PyObject * obj1 = 0 ;
53102 char * kwnames[] = {
53103 (char *) "self",(char *) "d", NULL
53104 };
53105
53106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53108 if (!SWIG_IsOK(res1)) {
53109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53110 }
53111 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53112 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53113 if (!SWIG_IsOK(ecode2)) {
53114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53115 }
53116 arg2 = static_cast< bool >(val2);
53117 {
53118 PyThreadState* __tstate = wxPyBeginAllowThreads();
53119 (arg1)->SetDone(arg2);
53120 wxPyEndAllowThreads(__tstate);
53121 if (PyErr_Occurred()) SWIG_fail;
53122 }
53123 resultobj = SWIG_Py_Void();
53124 return resultobj;
53125 fail:
53126 return NULL;
53127 }
53128
53129
53130 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53131 PyObject *resultobj = 0;
53132 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53133 wxRelationship result;
53134 void *argp1 = 0 ;
53135 int res1 = 0 ;
53136 PyObject *swig_obj[1] ;
53137
53138 if (!args) SWIG_fail;
53139 swig_obj[0] = args;
53140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53141 if (!SWIG_IsOK(res1)) {
53142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53143 }
53144 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53145 {
53146 PyThreadState* __tstate = wxPyBeginAllowThreads();
53147 result = (wxRelationship)(arg1)->GetRelationship();
53148 wxPyEndAllowThreads(__tstate);
53149 if (PyErr_Occurred()) SWIG_fail;
53150 }
53151 resultobj = SWIG_From_int(static_cast< int >(result));
53152 return resultobj;
53153 fail:
53154 return NULL;
53155 }
53156
53157
53158 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53159 PyObject *resultobj = 0;
53160 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53161 wxRelationship arg2 ;
53162 void *argp1 = 0 ;
53163 int res1 = 0 ;
53164 int val2 ;
53165 int ecode2 = 0 ;
53166 PyObject * obj0 = 0 ;
53167 PyObject * obj1 = 0 ;
53168 char * kwnames[] = {
53169 (char *) "self",(char *) "r", NULL
53170 };
53171
53172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53174 if (!SWIG_IsOK(res1)) {
53175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53176 }
53177 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53178 ecode2 = SWIG_AsVal_int(obj1, &val2);
53179 if (!SWIG_IsOK(ecode2)) {
53180 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53181 }
53182 arg2 = static_cast< wxRelationship >(val2);
53183 {
53184 PyThreadState* __tstate = wxPyBeginAllowThreads();
53185 (arg1)->SetRelationship(arg2);
53186 wxPyEndAllowThreads(__tstate);
53187 if (PyErr_Occurred()) SWIG_fail;
53188 }
53189 resultobj = SWIG_Py_Void();
53190 return resultobj;
53191 fail:
53192 return NULL;
53193 }
53194
53195
53196 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53197 PyObject *resultobj = 0;
53198 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53199 wxWindow *arg2 = (wxWindow *) 0 ;
53200 bool result;
53201 void *argp1 = 0 ;
53202 int res1 = 0 ;
53203 void *argp2 = 0 ;
53204 int res2 = 0 ;
53205 PyObject * obj0 = 0 ;
53206 PyObject * obj1 = 0 ;
53207 char * kwnames[] = {
53208 (char *) "self",(char *) "otherW", NULL
53209 };
53210
53211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53213 if (!SWIG_IsOK(res1)) {
53214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53215 }
53216 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53218 if (!SWIG_IsOK(res2)) {
53219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53220 }
53221 arg2 = reinterpret_cast< wxWindow * >(argp2);
53222 {
53223 PyThreadState* __tstate = wxPyBeginAllowThreads();
53224 result = (bool)(arg1)->ResetIfWin(arg2);
53225 wxPyEndAllowThreads(__tstate);
53226 if (PyErr_Occurred()) SWIG_fail;
53227 }
53228 {
53229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53230 }
53231 return resultobj;
53232 fail:
53233 return NULL;
53234 }
53235
53236
53237 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53238 PyObject *resultobj = 0;
53239 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53240 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53241 wxWindow *arg3 = (wxWindow *) 0 ;
53242 bool result;
53243 void *argp1 = 0 ;
53244 int res1 = 0 ;
53245 void *argp2 = 0 ;
53246 int res2 = 0 ;
53247 void *argp3 = 0 ;
53248 int res3 = 0 ;
53249 PyObject * obj0 = 0 ;
53250 PyObject * obj1 = 0 ;
53251 PyObject * obj2 = 0 ;
53252 char * kwnames[] = {
53253 (char *) "self",(char *) "constraints",(char *) "win", NULL
53254 };
53255
53256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53258 if (!SWIG_IsOK(res1)) {
53259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53260 }
53261 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53263 if (!SWIG_IsOK(res2)) {
53264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53265 }
53266 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53267 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53268 if (!SWIG_IsOK(res3)) {
53269 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53270 }
53271 arg3 = reinterpret_cast< wxWindow * >(argp3);
53272 {
53273 PyThreadState* __tstate = wxPyBeginAllowThreads();
53274 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53275 wxPyEndAllowThreads(__tstate);
53276 if (PyErr_Occurred()) SWIG_fail;
53277 }
53278 {
53279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53280 }
53281 return resultobj;
53282 fail:
53283 return NULL;
53284 }
53285
53286
53287 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53288 PyObject *resultobj = 0;
53289 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53290 wxEdge arg2 ;
53291 wxWindow *arg3 = (wxWindow *) 0 ;
53292 wxWindow *arg4 = (wxWindow *) 0 ;
53293 int result;
53294 void *argp1 = 0 ;
53295 int res1 = 0 ;
53296 int val2 ;
53297 int ecode2 = 0 ;
53298 void *argp3 = 0 ;
53299 int res3 = 0 ;
53300 void *argp4 = 0 ;
53301 int res4 = 0 ;
53302 PyObject * obj0 = 0 ;
53303 PyObject * obj1 = 0 ;
53304 PyObject * obj2 = 0 ;
53305 PyObject * obj3 = 0 ;
53306 char * kwnames[] = {
53307 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53308 };
53309
53310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53312 if (!SWIG_IsOK(res1)) {
53313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53314 }
53315 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53316 ecode2 = SWIG_AsVal_int(obj1, &val2);
53317 if (!SWIG_IsOK(ecode2)) {
53318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53319 }
53320 arg2 = static_cast< wxEdge >(val2);
53321 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53322 if (!SWIG_IsOK(res3)) {
53323 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53324 }
53325 arg3 = reinterpret_cast< wxWindow * >(argp3);
53326 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53327 if (!SWIG_IsOK(res4)) {
53328 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53329 }
53330 arg4 = reinterpret_cast< wxWindow * >(argp4);
53331 {
53332 PyThreadState* __tstate = wxPyBeginAllowThreads();
53333 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53334 wxPyEndAllowThreads(__tstate);
53335 if (PyErr_Occurred()) SWIG_fail;
53336 }
53337 resultobj = SWIG_From_int(static_cast< int >(result));
53338 return resultobj;
53339 fail:
53340 return NULL;
53341 }
53342
53343
53344 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53345 PyObject *obj;
53346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53347 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53348 return SWIG_Py_Void();
53349 }
53350
53351 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53352 PyObject *resultobj = 0;
53353 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53354 wxIndividualLayoutConstraint *result = 0 ;
53355 void *argp1 = 0 ;
53356 int res1 = 0 ;
53357 PyObject *swig_obj[1] ;
53358
53359 if (!args) SWIG_fail;
53360 swig_obj[0] = args;
53361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53362 if (!SWIG_IsOK(res1)) {
53363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53364 }
53365 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53366 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53368 return resultobj;
53369 fail:
53370 return NULL;
53371 }
53372
53373
53374 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53375 PyObject *resultobj = 0;
53376 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53377 wxIndividualLayoutConstraint *result = 0 ;
53378 void *argp1 = 0 ;
53379 int res1 = 0 ;
53380 PyObject *swig_obj[1] ;
53381
53382 if (!args) SWIG_fail;
53383 swig_obj[0] = args;
53384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53385 if (!SWIG_IsOK(res1)) {
53386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53387 }
53388 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53389 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53391 return resultobj;
53392 fail:
53393 return NULL;
53394 }
53395
53396
53397 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53398 PyObject *resultobj = 0;
53399 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53400 wxIndividualLayoutConstraint *result = 0 ;
53401 void *argp1 = 0 ;
53402 int res1 = 0 ;
53403 PyObject *swig_obj[1] ;
53404
53405 if (!args) SWIG_fail;
53406 swig_obj[0] = args;
53407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53408 if (!SWIG_IsOK(res1)) {
53409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53410 }
53411 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53412 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53414 return resultobj;
53415 fail:
53416 return NULL;
53417 }
53418
53419
53420 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53421 PyObject *resultobj = 0;
53422 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53423 wxIndividualLayoutConstraint *result = 0 ;
53424 void *argp1 = 0 ;
53425 int res1 = 0 ;
53426 PyObject *swig_obj[1] ;
53427
53428 if (!args) SWIG_fail;
53429 swig_obj[0] = args;
53430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53431 if (!SWIG_IsOK(res1)) {
53432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53433 }
53434 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53435 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53437 return resultobj;
53438 fail:
53439 return NULL;
53440 }
53441
53442
53443 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53444 PyObject *resultobj = 0;
53445 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53446 wxIndividualLayoutConstraint *result = 0 ;
53447 void *argp1 = 0 ;
53448 int res1 = 0 ;
53449 PyObject *swig_obj[1] ;
53450
53451 if (!args) SWIG_fail;
53452 swig_obj[0] = args;
53453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53454 if (!SWIG_IsOK(res1)) {
53455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53456 }
53457 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53458 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53460 return resultobj;
53461 fail:
53462 return NULL;
53463 }
53464
53465
53466 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53467 PyObject *resultobj = 0;
53468 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53469 wxIndividualLayoutConstraint *result = 0 ;
53470 void *argp1 = 0 ;
53471 int res1 = 0 ;
53472 PyObject *swig_obj[1] ;
53473
53474 if (!args) SWIG_fail;
53475 swig_obj[0] = args;
53476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53477 if (!SWIG_IsOK(res1)) {
53478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53479 }
53480 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53481 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53483 return resultobj;
53484 fail:
53485 return NULL;
53486 }
53487
53488
53489 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53490 PyObject *resultobj = 0;
53491 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53492 wxIndividualLayoutConstraint *result = 0 ;
53493 void *argp1 = 0 ;
53494 int res1 = 0 ;
53495 PyObject *swig_obj[1] ;
53496
53497 if (!args) SWIG_fail;
53498 swig_obj[0] = args;
53499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53500 if (!SWIG_IsOK(res1)) {
53501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53502 }
53503 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53504 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53506 return resultobj;
53507 fail:
53508 return NULL;
53509 }
53510
53511
53512 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53513 PyObject *resultobj = 0;
53514 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53515 wxIndividualLayoutConstraint *result = 0 ;
53516 void *argp1 = 0 ;
53517 int res1 = 0 ;
53518 PyObject *swig_obj[1] ;
53519
53520 if (!args) SWIG_fail;
53521 swig_obj[0] = args;
53522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53523 if (!SWIG_IsOK(res1)) {
53524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53525 }
53526 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53527 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
53528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53529 return resultobj;
53530 fail:
53531 return NULL;
53532 }
53533
53534
53535 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53536 PyObject *resultobj = 0;
53537 wxLayoutConstraints *result = 0 ;
53538
53539 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
53540 {
53541 PyThreadState* __tstate = wxPyBeginAllowThreads();
53542 result = (wxLayoutConstraints *)new wxLayoutConstraints();
53543 wxPyEndAllowThreads(__tstate);
53544 if (PyErr_Occurred()) SWIG_fail;
53545 }
53546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
53547 return resultobj;
53548 fail:
53549 return NULL;
53550 }
53551
53552
53553 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53554 PyObject *resultobj = 0;
53555 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53556 void *argp1 = 0 ;
53557 int res1 = 0 ;
53558 PyObject *swig_obj[1] ;
53559
53560 if (!args) SWIG_fail;
53561 swig_obj[0] = args;
53562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
53563 if (!SWIG_IsOK(res1)) {
53564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53565 }
53566 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53567 {
53568 PyThreadState* __tstate = wxPyBeginAllowThreads();
53569 delete arg1;
53570
53571 wxPyEndAllowThreads(__tstate);
53572 if (PyErr_Occurred()) SWIG_fail;
53573 }
53574 resultobj = SWIG_Py_Void();
53575 return resultobj;
53576 fail:
53577 return NULL;
53578 }
53579
53580
53581 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53582 PyObject *resultobj = 0;
53583 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53584 wxWindow *arg2 = (wxWindow *) 0 ;
53585 int *arg3 = (int *) 0 ;
53586 bool result;
53587 void *argp1 = 0 ;
53588 int res1 = 0 ;
53589 void *argp2 = 0 ;
53590 int res2 = 0 ;
53591 int temp3 ;
53592 int res3 = SWIG_TMPOBJ ;
53593 PyObject * obj0 = 0 ;
53594 PyObject * obj1 = 0 ;
53595 char * kwnames[] = {
53596 (char *) "self",(char *) "win", NULL
53597 };
53598
53599 arg3 = &temp3;
53600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53602 if (!SWIG_IsOK(res1)) {
53603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53604 }
53605 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53606 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53607 if (!SWIG_IsOK(res2)) {
53608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53609 }
53610 arg2 = reinterpret_cast< wxWindow * >(argp2);
53611 {
53612 PyThreadState* __tstate = wxPyBeginAllowThreads();
53613 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53614 wxPyEndAllowThreads(__tstate);
53615 if (PyErr_Occurred()) SWIG_fail;
53616 }
53617 {
53618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53619 }
53620 if (SWIG_IsTmpObj(res3)) {
53621 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53622 } else {
53623 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53624 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53625 }
53626 return resultobj;
53627 fail:
53628 return NULL;
53629 }
53630
53631
53632 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53633 PyObject *resultobj = 0;
53634 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53635 bool result;
53636 void *argp1 = 0 ;
53637 int res1 = 0 ;
53638 PyObject *swig_obj[1] ;
53639
53640 if (!args) SWIG_fail;
53641 swig_obj[0] = args;
53642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53643 if (!SWIG_IsOK(res1)) {
53644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53645 }
53646 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53647 {
53648 PyThreadState* __tstate = wxPyBeginAllowThreads();
53649 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53650 wxPyEndAllowThreads(__tstate);
53651 if (PyErr_Occurred()) SWIG_fail;
53652 }
53653 {
53654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53655 }
53656 return resultobj;
53657 fail:
53658 return NULL;
53659 }
53660
53661
53662 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53663 PyObject *obj;
53664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53665 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53666 return SWIG_Py_Void();
53667 }
53668
53669 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53670 return SWIG_Python_InitShadowInstance(args);
53671 }
53672
53673 static PyMethodDef SwigMethods[] = {
53674 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53675 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53676 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53677 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53678 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53679 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53680 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53681 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53682 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53684 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53686 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53689 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53695 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53696 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53697 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53699 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53700 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53701 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53702 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53703 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53704 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53705 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53707 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53713 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53714 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53715 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53716 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53717 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53718 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53719 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53721 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53723 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53726 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53729 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53730 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53731 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53736 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53737 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53738 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53739 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53741 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53743 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53745 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53747 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53749 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53750 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53752 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53754 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53755 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53756 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53757 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53767 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Rect_InsideRect", (PyCFunction) _wrap_Rect_InsideRect, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53776 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53777 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53778 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53779 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53780 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53781 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53782 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53783 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53784 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53786 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53787 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53788 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53793 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53794 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53795 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53796 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53797 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53803 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53810 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53811 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53812 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53813 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53815 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53816 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53817 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53819 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53820 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53821 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53822 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53827 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53828 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53829 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53830 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53831 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53832 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53835 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53836 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53837 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53839 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53840 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53842 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53843 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
53844 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53845 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53846 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53847 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53848 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53849 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53850 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53851 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53852 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53853 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53854 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53855 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53856 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53858 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53863 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53864 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53865 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53866 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53867 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53869 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53872 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53875 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53876 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53877 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53878 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53879 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53880 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53883 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53884 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53885 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53888 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53889 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53890 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53891 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53895 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53900 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53901 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53902 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53903 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53904 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53905 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53906 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53913 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53914 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53916 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53917 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53918 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53924 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53925 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53927 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53928 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53929 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53930 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53931 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53932 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53933 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53934 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53936 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53937 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53938 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53939 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53940 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53941 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53942 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53943 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53945 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53954 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53963 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53966 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53967 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53974 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53982 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53983 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53984 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53985 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53987 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53988 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53990 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53992 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53993 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53994 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53996 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53997 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53999 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54000 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54001 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54002 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54004 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54005 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54014 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54021 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54022 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54028 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54029 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54031 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54032 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54033 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54034 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54035 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54036 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54037 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54038 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54039 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54040 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54041 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54042 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54043 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54044 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54045 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54046 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54047 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54048 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54049 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54050 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54051 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54052 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54053 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54054 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54055 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54056 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54057 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54058 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54059 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54060 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54061 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54062 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54063 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54065 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54066 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54067 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54068 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54071 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54075 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54079 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54080 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54081 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54082 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54084 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54085 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54087 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54089 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54091 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54093 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54094 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54095 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54096 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54097 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54098 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54099 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54100 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54101 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54102 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54104 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54105 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54106 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54107 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54108 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54110 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54111 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54112 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54114 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54115 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54116 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54117 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54119 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54120 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54121 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54122 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54123 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54124 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54125 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54126 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54127 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54129 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54130 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54131 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54133 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54134 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54135 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54136 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54137 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54140 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54141 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54142 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54143 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54144 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54145 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54147 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54149 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54150 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54151 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54152 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54153 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54154 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54155 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54156 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54157 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54158 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54159 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54160 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54161 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54162 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54163 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54164 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54165 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54166 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54167 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54168 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54169 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54170 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54171 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54172 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54174 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54175 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54176 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54177 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54178 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54179 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54180 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54181 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54182 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54183 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54184 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54185 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54186 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54187 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54188 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54189 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54190 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54191 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54192 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54193 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54194 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54195 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54196 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54197 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54198 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54199 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54200 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54201 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54202 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54203 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54204 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54205 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54207 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54208 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54209 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54210 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54211 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54212 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54213 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54215 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54216 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54217 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54218 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54219 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54220 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54221 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54222 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54223 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54225 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54226 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54227 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54228 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54229 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54230 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54231 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54232 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54233 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54234 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54235 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54236 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54237 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54238 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54239 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54240 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54241 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54242 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54243 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54244 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54245 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54246 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54247 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54248 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54249 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54250 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54251 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54252 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54253 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54254 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54255 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54256 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54257 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54258 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54259 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54260 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54261 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54262 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54263 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54264 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54265 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54266 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54267 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54268 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54269 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54270 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54271 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54272 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54273 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54274 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54275 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54276 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54277 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54278 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54279 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54280 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54281 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54282 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54283 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54284 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54285 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54286 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54287 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54288 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54289 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54290 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54291 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54292 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54293 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54294 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54295 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54296 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54297 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54298 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54299 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54300 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54301 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54302 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54303 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54304 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54305 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54306 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54307 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54308 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54309 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54310 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54311 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54312 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54313 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54314 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54315 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54316 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54318 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54319 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54320 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54321 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54322 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54323 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54324 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54325 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54326 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54327 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54329 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54330 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54331 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54332 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54333 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54334 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54335 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54336 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54338 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54339 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54340 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54342 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54344 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54345 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54346 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54347 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54348 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54349 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54350 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54351 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54352 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54353 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54354 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54355 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54356 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54357 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54358 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54359 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54360 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54361 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54362 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54364 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54365 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54366 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54367 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54369 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54370 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54371 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54372 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54373 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54374 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54375 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54376 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54377 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54378 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54379 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54380 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54382 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54383 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54384 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54385 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54386 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54387 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54389 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54390 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54391 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54392 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54393 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54394 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54395 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54396 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54397 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54399 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54401 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54402 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54403 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54404 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54405 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54406 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54407 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54408 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54409 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54410 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54411 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54412 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54413 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54414 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54415 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54417 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54418 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54419 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54420 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54421 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54423 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54424 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54425 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54426 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54428 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54429 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54430 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54431 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54432 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54433 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54434 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54435 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54436 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54437 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54438 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54439 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54440 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54441 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54442 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54443 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54444 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54445 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54446 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54447 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54448 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54449 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54450 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54451 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54453 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54455 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54456 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54457 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54458 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54459 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54460 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54461 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54462 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54463 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54464 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54466 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54467 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54468 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54469 { (char *)"PyApp_DisplayAvailable", (PyCFunction)_wrap_PyApp_DisplayAvailable, METH_NOARGS, NULL},
54470 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54471 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54472 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54473 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54474 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54475 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54477 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54478 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54479 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54480 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54481 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54482 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54483 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54484 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54485 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54486 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54487 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54488 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54489 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54490 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54491 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54492 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54493 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54494 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54495 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54496 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54497 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54498 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54499 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54500 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54501 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54502 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54503 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54504 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54505 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54506 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54507 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54508 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54509 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54510 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54511 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54512 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54513 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54514 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54515 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
54516 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
54517 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
54518 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
54519 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
54520 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
54521 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
54522 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
54523 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
54524 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
54525 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
54526 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
54527 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54528 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
54529 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
54530 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
54531 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
54532 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54533 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
54534 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54535 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
54536 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
54537 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
54538 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54539 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
54540 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
54541 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54542 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54543 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
54544 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54545 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54546 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54547 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
54548 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54549 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54550 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
54551 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
54552 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
54553 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
54554 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
54555 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
54556 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54557 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
54558 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
54559 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
54560 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
54561 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
54562 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
54563 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
54564 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
54565 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
54566 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
54567 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
54568 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
54569 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
54570 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
54571 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
54572 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
54573 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
54574 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
54575 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
54576 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
54577 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
54578 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
54579 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
54580 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54581 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54582 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54583 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54584 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
54585 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
54586 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54587 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
54588 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
54589 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
54590 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
54591 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
54592 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54594 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
54595 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
54596 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
54597 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54598 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
54599 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54600 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54601 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54602 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54603 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54604 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54605 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54607 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54608 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54609 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54612 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54613 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54614 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54615 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54616 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54617 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54619 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54620 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54621 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54622 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54623 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54624 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54625 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54626 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54627 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54628 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54629 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54630 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54631 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54632 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54633 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54635 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54636 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54637 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54638 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54639 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54640 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54641 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54642 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54643 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54644 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54645 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54646 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54647 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54649 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54650 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54651 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54652 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54653 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54654 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54655 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54656 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54657 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54658 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54659 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54660 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54661 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54662 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54663 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54664 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54665 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54666 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54667 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54668 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54669 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54670 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54671 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54672 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54673 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54674 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54675 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54676 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54677 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54678 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54679 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54680 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54681 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54682 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54683 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54684 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54685 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54686 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54687 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54688 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54689 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54690 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54691 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54692 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54693 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54694 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54695 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54696 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54697 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54698 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54699 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54700 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54701 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54702 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54703 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54704 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54705 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54706 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54707 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54708 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54709 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54710 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54711 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54712 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54713 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54714 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54715 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54716 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54717 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54718 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54719 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54720 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54721 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54722 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54723 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54724 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54725 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54726 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54727 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54728 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54729 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54730 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54731 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54732 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54733 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54734 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54736 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54737 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54738 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54739 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54740 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54741 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54742 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54743 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54744 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54745 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54746 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54747 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54748 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54749 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54750 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54751 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54752 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54753 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54754 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54755 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54756 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54757 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54758 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54759 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54760 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54761 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54762 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54763 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54764 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54765 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54766 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54767 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54768 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54769 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54770 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54771 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54773 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54776 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54777 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54778 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54779 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54780 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54781 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54782 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54783 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54784 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54785 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54786 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54787 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54788 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54789 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54790 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54791 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54792 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54793 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54794 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54795 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54796 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54797 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54798 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54799 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54800 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54801 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54802 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54803 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54804 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54805 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54806 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54807 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54808 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54809 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54810 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54811 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54812 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54813 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54814 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54815 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54816 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54817 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54818 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54819 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54820 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54821 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54822 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54823 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54824 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54825 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54826 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54827 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54828 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54829 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54830 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54831 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54832 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54833 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54834 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54835 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54836 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54837 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54838 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54839 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54840 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54841 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54842 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54843 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54844 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54845 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54846 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54847 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54848 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54849 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54850 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54851 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54852 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54853 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54854 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54855 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54856 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54857 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54859 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54860 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54861 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54862 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54863 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54864 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54865 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54866 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54867 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54868 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54869 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54870 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54871 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54872 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54873 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54874 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54875 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54876 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54877 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54878 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54879 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54880 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54881 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54882 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54883 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54884 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54885 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54886 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54887 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54888 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54889 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54891 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54892 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54893 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54894 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54895 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54896 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54897 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54898 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54899 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54900 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54901 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54902 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54903 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54904 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54905 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54906 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54907 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54908 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54909 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54910 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54911 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54912 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54913 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54914 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54915 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54916 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54917 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54918 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54919 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54920 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54921 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54922 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54923 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54924 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54925 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54926 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54927 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54928 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54929 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54930 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54931 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54932 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54933 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54934 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54935 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54936 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54937 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54938 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54939 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54940 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54941 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54942 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54943 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54944 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54945 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54946 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54947 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54948 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54949 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54950 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54951 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54952 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54953 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54954 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54955 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54956 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54957 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54958 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54959 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54960 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54961 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54962 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54963 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54964 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54965 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54966 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54967 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54968 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54969 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54970 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54971 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54972 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54973 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54975 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54976 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54978 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
54979 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54980 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
54981 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54982 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
54983 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54985 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54986 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54987 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54988 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54989 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54990 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54991 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54992 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54993 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54994 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54997 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54998 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54999 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55000 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55001 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55002 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55003 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55005 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55006 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55007 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55008 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55009 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55010 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55011 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55012 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55013 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55014 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55016 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55017 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55018 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55019 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55020 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55021 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55023 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55024 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55025 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55026 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55027 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55028 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55029 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55030 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55031 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55032 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55035 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55036 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55037 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55038 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55039 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55040 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55041 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55042 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55043 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55044 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55045 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55046 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55048 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55049 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55050 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55051 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55052 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55053 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55054 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55055 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55056 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55057 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55058 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55059 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55060 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55062 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55063 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55064 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55065 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55066 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55067 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55068 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55069 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55070 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55071 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55072 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55073 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55074 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55075 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55076 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55077 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55078 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55079 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55080 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55081 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55082 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55085 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55086 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55087 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55088 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55089 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55090 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55091 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55092 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55093 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55094 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55095 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55096 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55097 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55098 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55099 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55100 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55101 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55102 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55103 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55104 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55105 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55106 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55107 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55108 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55110 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55111 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55112 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55113 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55114 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55115 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55116 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55117 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55119 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55120 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55121 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55122 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55123 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55124 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55126 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55127 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55128 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55129 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55130 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55131 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55132 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55133 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55134 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55137 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55138 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55139 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55140 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55141 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55142 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55143 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55144 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55145 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55146 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55147 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55148 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55149 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55150 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55151 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55152 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55153 { NULL, NULL, 0, NULL }
55154 };
55155
55156
55157 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55158
55159 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55160 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55161 }
55162 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55163 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55164 }
55165 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55166 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55167 }
55168 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55169 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55170 }
55171 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55172 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55173 }
55174 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55175 return (void *)((wxSizer *) ((wxGridSizer *) x));
55176 }
55177 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55178 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55179 }
55180 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55181 return (void *)((wxSizer *) ((wxPySizer *) x));
55182 }
55183 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55184 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55185 }
55186 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55187 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55188 }
55189 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55190 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55191 }
55192 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55193 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55194 }
55195 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55196 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55197 }
55198 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55199 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55200 }
55201 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55202 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55203 }
55204 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55205 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55206 }
55207 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55208 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55209 }
55210 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55211 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55212 }
55213 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55214 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55215 }
55216 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55217 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55218 }
55219 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55220 return (void *)((wxEvent *) ((wxPyEvent *) x));
55221 }
55222 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55223 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55224 }
55225 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55226 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55227 }
55228 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55229 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55230 }
55231 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55232 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55233 }
55234 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55235 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55236 }
55237 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55238 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55239 }
55240 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55241 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55242 }
55243 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55244 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55245 }
55246 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55247 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55248 }
55249 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55250 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55251 }
55252 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55253 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55254 }
55255 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55256 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55257 }
55258 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55259 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55260 }
55261 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55262 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55263 }
55264 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55265 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55266 }
55267 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55268 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55269 }
55270 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55271 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55272 }
55273 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55274 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55275 }
55276 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55277 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55278 }
55279 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55280 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55281 }
55282 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55283 return (void *)((wxEvent *) ((wxShowEvent *) x));
55284 }
55285 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55286 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55287 }
55288 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55289 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55290 }
55291 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55292 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55293 }
55294 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55295 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55296 }
55297 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55298 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55299 }
55300 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55301 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55302 }
55303 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55304 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55305 }
55306 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55307 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55308 }
55309 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55310 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55311 }
55312 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55313 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55314 }
55315 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55316 return (void *)((wxControl *) ((wxControlWithItems *) x));
55317 }
55318 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55319 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55320 }
55321 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55322 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55323 }
55324 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55325 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55326 }
55327 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55328 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55329 }
55330 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55331 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55332 }
55333 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55334 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55335 }
55336 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55337 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55338 }
55339 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55340 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55341 }
55342 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55343 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55344 }
55345 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55346 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55347 }
55348 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55349 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55350 }
55351 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55352 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55353 }
55354 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55355 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55356 }
55357 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55358 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55359 }
55360 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55361 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55362 }
55363 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55364 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55365 }
55366 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55367 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55368 }
55369 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55370 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55371 }
55372 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55373 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55374 }
55375 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55376 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55377 }
55378 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55379 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55380 }
55381 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55382 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55383 }
55384 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55385 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55386 }
55387 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55388 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55389 }
55390 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55391 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55392 }
55393 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55394 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55395 }
55396 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55397 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55398 }
55399 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55400 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55401 }
55402 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55403 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55404 }
55405 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55406 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55407 }
55408 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55409 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55410 }
55411 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55412 return (void *)((wxObject *) ((wxSizerItem *) x));
55413 }
55414 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55415 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55416 }
55417 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55418 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55419 }
55420 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55421 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55422 }
55423 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55424 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55425 }
55426 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55427 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55428 }
55429 static void *_p_wxSizerTo_p_wxObject(void *x) {
55430 return (void *)((wxObject *) ((wxSizer *) x));
55431 }
55432 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55433 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55434 }
55435 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55436 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55437 }
55438 static void *_p_wxEventTo_p_wxObject(void *x) {
55439 return (void *)((wxObject *) ((wxEvent *) x));
55440 }
55441 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55442 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55443 }
55444 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55445 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55446 }
55447 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55448 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55449 }
55450 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55451 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55452 }
55453 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55454 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55455 }
55456 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55457 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55458 }
55459 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55460 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55461 }
55462 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55463 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55464 }
55465 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55466 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55467 }
55468 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55469 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55470 }
55471 static void *_p_wxControlTo_p_wxObject(void *x) {
55472 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55473 }
55474 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55475 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55476 }
55477 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55478 return (void *)((wxObject *) ((wxFSFile *) x));
55479 }
55480 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55481 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55482 }
55483 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55484 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55485 }
55486 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55487 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55488 }
55489 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55490 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55491 }
55492 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55493 return (void *)((wxObject *) ((wxMenuItem *) x));
55494 }
55495 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55496 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55497 }
55498 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55499 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55500 }
55501 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55502 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55503 }
55504 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55505 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55506 }
55507 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55508 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55509 }
55510 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55511 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55512 }
55513 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55514 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
55515 }
55516 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
55517 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
55518 }
55519 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
55520 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
55521 }
55522 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
55523 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
55524 }
55525 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
55526 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
55527 }
55528 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
55529 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
55530 }
55531 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
55532 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
55533 }
55534 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
55535 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
55536 }
55537 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
55538 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55539 }
55540 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
55541 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55542 }
55543 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
55544 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
55545 }
55546 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
55547 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
55548 }
55549 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
55550 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
55551 }
55552 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
55553 return (void *)((wxObject *) ((wxImageHandler *) x));
55554 }
55555 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
55556 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
55557 }
55558 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
55559 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
55560 }
55561 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
55562 return (void *)((wxObject *) ((wxEvtHandler *) x));
55563 }
55564 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
55565 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
55566 }
55567 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
55568 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55569 }
55570 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
55571 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
55572 }
55573 static void *_p_wxImageTo_p_wxObject(void *x) {
55574 return (void *)((wxObject *) ((wxImage *) x));
55575 }
55576 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
55577 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
55578 }
55579 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
55580 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55581 }
55582 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
55583 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
55584 }
55585 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
55586 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
55587 }
55588 static void *_p_wxWindowTo_p_wxObject(void *x) {
55589 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
55590 }
55591 static void *_p_wxMenuTo_p_wxObject(void *x) {
55592 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
55593 }
55594 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
55595 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
55596 }
55597 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
55598 return (void *)((wxObject *) ((wxFileSystem *) x));
55599 }
55600 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
55601 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
55602 }
55603 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55604 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55605 }
55606 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55607 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55608 }
55609 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55610 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55611 }
55612 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55613 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55614 }
55615 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55616 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55617 }
55618 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55619 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55620 }
55621 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55622 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55623 }
55624 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55625 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55626 }
55627 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55628 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55629 }
55630 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55631 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55632 }
55633 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55634 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55635 }
55636 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55637 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55638 }
55639 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55640 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55641 }
55642 static void *_p_wxControlTo_p_wxWindow(void *x) {
55643 return (void *)((wxWindow *) ((wxControl *) x));
55644 }
55645 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55646 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55647 }
55648 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55649 return (void *)((wxWindow *) ((wxMenuBar *) x));
55650 }
55651 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55652 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55653 }
55654 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55655 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55656 }
55657 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55658 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55659 }
55660 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55661 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55662 }
55663 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55664 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55665 }
55666 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55667 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55668 }
55669 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55670 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55671 }
55672 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55673 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55674 }
55675 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55676 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55677 }
55678 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55679 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55680 }
55681 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55682 return (void *)((wxValidator *) ((wxPyValidator *) x));
55683 }
55684 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55685 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55686 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};
55687 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55688 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55689 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55690 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55691 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55692 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55693 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55694 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55695 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55696 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55697 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55698 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55699 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55700 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55701 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55702 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55703 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55704 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55705 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55706 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55707 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55708 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55709 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55710 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55711 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55712 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55713 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55714 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55715 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55716 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55717 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55718 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55719 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55720 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55721 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55722 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55723 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55724 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55725 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55726 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55727 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55728 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55729 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55730 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55731 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55732 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55733 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55734 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55735 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55736 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55737 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55738 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55739 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55740 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55741 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55742 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55743 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55744 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55745 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55746 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55747 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55748 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55749 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55750 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55751 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55752 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55753 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55754 static swig_type_info _swigt__p_wxLayoutDirection = {"_p_wxLayoutDirection", "wxLayoutDirection *", 0, 0, (void*)0, 0};
55755 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55756 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55757 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55758 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55759 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55760 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55761 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55762 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55763 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55764 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55765 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55766 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55767 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55768 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55769 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55770 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55771 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55772 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55773 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55774 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55775 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55776 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55777 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55778 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55779 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55780 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55781 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55782 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55783 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55784 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55785 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55786 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55787 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55788 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55789 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55790 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55791 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55792 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55793 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55794 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55795 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55796 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55797 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55798 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55799 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55800 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55801 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55802 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55803 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55804 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55805 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55806 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55807 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55808 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55809 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55810 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55811 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55812 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55813 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55814 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55815 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55816 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55817
55818 static swig_type_info *swig_type_initial[] = {
55819 &_swigt__p_buffer,
55820 &_swigt__p_char,
55821 &_swigt__p_form_ops_t,
55822 &_swigt__p_int,
55823 &_swigt__p_long,
55824 &_swigt__p_unsigned_char,
55825 &_swigt__p_unsigned_int,
55826 &_swigt__p_unsigned_long,
55827 &_swigt__p_wxANIHandler,
55828 &_swigt__p_wxAcceleratorEntry,
55829 &_swigt__p_wxAcceleratorTable,
55830 &_swigt__p_wxActivateEvent,
55831 &_swigt__p_wxAppTraits,
55832 &_swigt__p_wxArrayString,
55833 &_swigt__p_wxBMPHandler,
55834 &_swigt__p_wxBitmap,
55835 &_swigt__p_wxBoxSizer,
55836 &_swigt__p_wxButton,
55837 &_swigt__p_wxCURHandler,
55838 &_swigt__p_wxCaret,
55839 &_swigt__p_wxChildFocusEvent,
55840 &_swigt__p_wxClipboardTextEvent,
55841 &_swigt__p_wxCloseEvent,
55842 &_swigt__p_wxColour,
55843 &_swigt__p_wxCommandEvent,
55844 &_swigt__p_wxContextMenuEvent,
55845 &_swigt__p_wxControl,
55846 &_swigt__p_wxControlWithItems,
55847 &_swigt__p_wxCursor,
55848 &_swigt__p_wxDC,
55849 &_swigt__p_wxDateEvent,
55850 &_swigt__p_wxDateTime,
55851 &_swigt__p_wxDisplayChangedEvent,
55852 &_swigt__p_wxDropFilesEvent,
55853 &_swigt__p_wxDuplexMode,
55854 &_swigt__p_wxEraseEvent,
55855 &_swigt__p_wxEvent,
55856 &_swigt__p_wxEventLoop,
55857 &_swigt__p_wxEventLoopActivator,
55858 &_swigt__p_wxEvtHandler,
55859 &_swigt__p_wxFSFile,
55860 &_swigt__p_wxFileSystem,
55861 &_swigt__p_wxFileSystemHandler,
55862 &_swigt__p_wxFlexGridSizer,
55863 &_swigt__p_wxFocusEvent,
55864 &_swigt__p_wxFont,
55865 &_swigt__p_wxFrame,
55866 &_swigt__p_wxGBPosition,
55867 &_swigt__p_wxGBSizerItem,
55868 &_swigt__p_wxGBSpan,
55869 &_swigt__p_wxGIFHandler,
55870 &_swigt__p_wxGridBagSizer,
55871 &_swigt__p_wxGridSizer,
55872 &_swigt__p_wxHelpEvent__Origin,
55873 &_swigt__p_wxICOHandler,
55874 &_swigt__p_wxIconizeEvent,
55875 &_swigt__p_wxIdleEvent,
55876 &_swigt__p_wxImage,
55877 &_swigt__p_wxImageHandler,
55878 &_swigt__p_wxImageHistogram,
55879 &_swigt__p_wxImage_HSVValue,
55880 &_swigt__p_wxImage_RGBValue,
55881 &_swigt__p_wxIndividualLayoutConstraint,
55882 &_swigt__p_wxInitDialogEvent,
55883 &_swigt__p_wxInputStream,
55884 &_swigt__p_wxInternetFSHandler,
55885 &_swigt__p_wxItemContainer,
55886 &_swigt__p_wxJPEGHandler,
55887 &_swigt__p_wxKeyEvent,
55888 &_swigt__p_wxLayoutConstraints,
55889 &_swigt__p_wxLayoutDirection,
55890 &_swigt__p_wxMaximizeEvent,
55891 &_swigt__p_wxMemoryFSHandler,
55892 &_swigt__p_wxMenu,
55893 &_swigt__p_wxMenuBar,
55894 &_swigt__p_wxMenuBarBase,
55895 &_swigt__p_wxMenuEvent,
55896 &_swigt__p_wxMenuItem,
55897 &_swigt__p_wxMouseCaptureChangedEvent,
55898 &_swigt__p_wxMouseCaptureLostEvent,
55899 &_swigt__p_wxMouseEvent,
55900 &_swigt__p_wxMoveEvent,
55901 &_swigt__p_wxNavigationKeyEvent,
55902 &_swigt__p_wxNcPaintEvent,
55903 &_swigt__p_wxNotifyEvent,
55904 &_swigt__p_wxObject,
55905 &_swigt__p_wxOutputStream,
55906 &_swigt__p_wxPCXHandler,
55907 &_swigt__p_wxPNGHandler,
55908 &_swigt__p_wxPNMHandler,
55909 &_swigt__p_wxPaintEvent,
55910 &_swigt__p_wxPaletteChangedEvent,
55911 &_swigt__p_wxPaperSize,
55912 &_swigt__p_wxPoint,
55913 &_swigt__p_wxPoint2D,
55914 &_swigt__p_wxPropagateOnce,
55915 &_swigt__p_wxPropagationDisabler,
55916 &_swigt__p_wxPyApp,
55917 &_swigt__p_wxPyCommandEvent,
55918 &_swigt__p_wxPyDropTarget,
55919 &_swigt__p_wxPyEvent,
55920 &_swigt__p_wxPyFileSystemHandler,
55921 &_swigt__p_wxPyImageHandler,
55922 &_swigt__p_wxPyInputStream,
55923 &_swigt__p_wxPySizer,
55924 &_swigt__p_wxPyValidator,
55925 &_swigt__p_wxQuantize,
55926 &_swigt__p_wxQueryNewPaletteEvent,
55927 &_swigt__p_wxRealPoint,
55928 &_swigt__p_wxRect,
55929 &_swigt__p_wxRegion,
55930 &_swigt__p_wxScrollEvent,
55931 &_swigt__p_wxScrollWinEvent,
55932 &_swigt__p_wxSetCursorEvent,
55933 &_swigt__p_wxShowEvent,
55934 &_swigt__p_wxSize,
55935 &_swigt__p_wxSizeEvent,
55936 &_swigt__p_wxSizer,
55937 &_swigt__p_wxSizerItem,
55938 &_swigt__p_wxStaticBox,
55939 &_swigt__p_wxStaticBoxSizer,
55940 &_swigt__p_wxStdDialogButtonSizer,
55941 &_swigt__p_wxSysColourChangedEvent,
55942 &_swigt__p_wxTIFFHandler,
55943 &_swigt__p_wxToolTip,
55944 &_swigt__p_wxUpdateUIEvent,
55945 &_swigt__p_wxValidator,
55946 &_swigt__p_wxVisualAttributes,
55947 &_swigt__p_wxWindow,
55948 &_swigt__p_wxWindowCreateEvent,
55949 &_swigt__p_wxWindowDestroyEvent,
55950 &_swigt__p_wxXPMHandler,
55951 &_swigt__p_wxZipFSHandler,
55952 };
55953
55954 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55955 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55956 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55957 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55958 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55959 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55960 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55961 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55962 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55963 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55964 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55965 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55966 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55967 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55968 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}};
55969 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55970 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}};
55971 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55972 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}};
55973 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55974 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55975 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55976 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55977 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55978 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}};
55979 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55980 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}};
55981 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55982 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55983 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55984 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55985 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55986 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55987 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55988 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55989 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55990 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}};
55991 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55992 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55993 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}};
55994 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55995 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55996 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}};
55997 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}};
55998 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55999 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56000 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56001 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56002 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56003 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56004 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56005 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56006 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}};
56007 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56008 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}};
56009 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56010 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56011 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56012 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}};
56013 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56014 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56015 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56016 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56017 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56018 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56019 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56020 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}};
56021 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56022 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56023 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56024 static swig_cast_info _swigc__p_wxLayoutDirection[] = { {&_swigt__p_wxLayoutDirection, 0, 0, 0},{0, 0, 0, 0}};
56025 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56026 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56027 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56028 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56029 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56030 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56031 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56032 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56033 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56034 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56035 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56036 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56037 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56038 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56039 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}};
56040 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56041 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56042 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56043 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56044 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56045 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56046 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56047 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56048 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56049 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56050 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56051 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56052 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56053 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56054 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56055 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56056 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56057 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56058 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56059 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56060 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56061 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56062 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56063 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56064 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56065 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56066 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56067 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56068 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56069 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56070 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56071 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}};
56072 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}};
56073 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56074 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56075 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56076 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56077 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56078 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56079 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56080 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}};
56081 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56082 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}};
56083 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56084 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56085 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56086 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56087
56088 static swig_cast_info *swig_cast_initial[] = {
56089 _swigc__p_buffer,
56090 _swigc__p_char,
56091 _swigc__p_form_ops_t,
56092 _swigc__p_int,
56093 _swigc__p_long,
56094 _swigc__p_unsigned_char,
56095 _swigc__p_unsigned_int,
56096 _swigc__p_unsigned_long,
56097 _swigc__p_wxANIHandler,
56098 _swigc__p_wxAcceleratorEntry,
56099 _swigc__p_wxAcceleratorTable,
56100 _swigc__p_wxActivateEvent,
56101 _swigc__p_wxAppTraits,
56102 _swigc__p_wxArrayString,
56103 _swigc__p_wxBMPHandler,
56104 _swigc__p_wxBitmap,
56105 _swigc__p_wxBoxSizer,
56106 _swigc__p_wxButton,
56107 _swigc__p_wxCURHandler,
56108 _swigc__p_wxCaret,
56109 _swigc__p_wxChildFocusEvent,
56110 _swigc__p_wxClipboardTextEvent,
56111 _swigc__p_wxCloseEvent,
56112 _swigc__p_wxColour,
56113 _swigc__p_wxCommandEvent,
56114 _swigc__p_wxContextMenuEvent,
56115 _swigc__p_wxControl,
56116 _swigc__p_wxControlWithItems,
56117 _swigc__p_wxCursor,
56118 _swigc__p_wxDC,
56119 _swigc__p_wxDateEvent,
56120 _swigc__p_wxDateTime,
56121 _swigc__p_wxDisplayChangedEvent,
56122 _swigc__p_wxDropFilesEvent,
56123 _swigc__p_wxDuplexMode,
56124 _swigc__p_wxEraseEvent,
56125 _swigc__p_wxEvent,
56126 _swigc__p_wxEventLoop,
56127 _swigc__p_wxEventLoopActivator,
56128 _swigc__p_wxEvtHandler,
56129 _swigc__p_wxFSFile,
56130 _swigc__p_wxFileSystem,
56131 _swigc__p_wxFileSystemHandler,
56132 _swigc__p_wxFlexGridSizer,
56133 _swigc__p_wxFocusEvent,
56134 _swigc__p_wxFont,
56135 _swigc__p_wxFrame,
56136 _swigc__p_wxGBPosition,
56137 _swigc__p_wxGBSizerItem,
56138 _swigc__p_wxGBSpan,
56139 _swigc__p_wxGIFHandler,
56140 _swigc__p_wxGridBagSizer,
56141 _swigc__p_wxGridSizer,
56142 _swigc__p_wxHelpEvent__Origin,
56143 _swigc__p_wxICOHandler,
56144 _swigc__p_wxIconizeEvent,
56145 _swigc__p_wxIdleEvent,
56146 _swigc__p_wxImage,
56147 _swigc__p_wxImageHandler,
56148 _swigc__p_wxImageHistogram,
56149 _swigc__p_wxImage_HSVValue,
56150 _swigc__p_wxImage_RGBValue,
56151 _swigc__p_wxIndividualLayoutConstraint,
56152 _swigc__p_wxInitDialogEvent,
56153 _swigc__p_wxInputStream,
56154 _swigc__p_wxInternetFSHandler,
56155 _swigc__p_wxItemContainer,
56156 _swigc__p_wxJPEGHandler,
56157 _swigc__p_wxKeyEvent,
56158 _swigc__p_wxLayoutConstraints,
56159 _swigc__p_wxLayoutDirection,
56160 _swigc__p_wxMaximizeEvent,
56161 _swigc__p_wxMemoryFSHandler,
56162 _swigc__p_wxMenu,
56163 _swigc__p_wxMenuBar,
56164 _swigc__p_wxMenuBarBase,
56165 _swigc__p_wxMenuEvent,
56166 _swigc__p_wxMenuItem,
56167 _swigc__p_wxMouseCaptureChangedEvent,
56168 _swigc__p_wxMouseCaptureLostEvent,
56169 _swigc__p_wxMouseEvent,
56170 _swigc__p_wxMoveEvent,
56171 _swigc__p_wxNavigationKeyEvent,
56172 _swigc__p_wxNcPaintEvent,
56173 _swigc__p_wxNotifyEvent,
56174 _swigc__p_wxObject,
56175 _swigc__p_wxOutputStream,
56176 _swigc__p_wxPCXHandler,
56177 _swigc__p_wxPNGHandler,
56178 _swigc__p_wxPNMHandler,
56179 _swigc__p_wxPaintEvent,
56180 _swigc__p_wxPaletteChangedEvent,
56181 _swigc__p_wxPaperSize,
56182 _swigc__p_wxPoint,
56183 _swigc__p_wxPoint2D,
56184 _swigc__p_wxPropagateOnce,
56185 _swigc__p_wxPropagationDisabler,
56186 _swigc__p_wxPyApp,
56187 _swigc__p_wxPyCommandEvent,
56188 _swigc__p_wxPyDropTarget,
56189 _swigc__p_wxPyEvent,
56190 _swigc__p_wxPyFileSystemHandler,
56191 _swigc__p_wxPyImageHandler,
56192 _swigc__p_wxPyInputStream,
56193 _swigc__p_wxPySizer,
56194 _swigc__p_wxPyValidator,
56195 _swigc__p_wxQuantize,
56196 _swigc__p_wxQueryNewPaletteEvent,
56197 _swigc__p_wxRealPoint,
56198 _swigc__p_wxRect,
56199 _swigc__p_wxRegion,
56200 _swigc__p_wxScrollEvent,
56201 _swigc__p_wxScrollWinEvent,
56202 _swigc__p_wxSetCursorEvent,
56203 _swigc__p_wxShowEvent,
56204 _swigc__p_wxSize,
56205 _swigc__p_wxSizeEvent,
56206 _swigc__p_wxSizer,
56207 _swigc__p_wxSizerItem,
56208 _swigc__p_wxStaticBox,
56209 _swigc__p_wxStaticBoxSizer,
56210 _swigc__p_wxStdDialogButtonSizer,
56211 _swigc__p_wxSysColourChangedEvent,
56212 _swigc__p_wxTIFFHandler,
56213 _swigc__p_wxToolTip,
56214 _swigc__p_wxUpdateUIEvent,
56215 _swigc__p_wxValidator,
56216 _swigc__p_wxVisualAttributes,
56217 _swigc__p_wxWindow,
56218 _swigc__p_wxWindowCreateEvent,
56219 _swigc__p_wxWindowDestroyEvent,
56220 _swigc__p_wxXPMHandler,
56221 _swigc__p_wxZipFSHandler,
56222 };
56223
56224
56225 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56226
56227 static swig_const_info swig_const_table[] = {
56228 {0, 0, 0, 0.0, 0, 0}};
56229
56230 #ifdef __cplusplus
56231 }
56232 #endif
56233 /* -----------------------------------------------------------------------------
56234 * Type initialization:
56235 * This problem is tough by the requirement that no dynamic
56236 * memory is used. Also, since swig_type_info structures store pointers to
56237 * swig_cast_info structures and swig_cast_info structures store pointers back
56238 * to swig_type_info structures, we need some lookup code at initialization.
56239 * The idea is that swig generates all the structures that are needed.
56240 * The runtime then collects these partially filled structures.
56241 * The SWIG_InitializeModule function takes these initial arrays out of
56242 * swig_module, and does all the lookup, filling in the swig_module.types
56243 * array with the correct data and linking the correct swig_cast_info
56244 * structures together.
56245 *
56246 * The generated swig_type_info structures are assigned staticly to an initial
56247 * array. We just loop though that array, and handle each type individually.
56248 * First we lookup if this type has been already loaded, and if so, use the
56249 * loaded structure instead of the generated one. Then we have to fill in the
56250 * cast linked list. The cast data is initially stored in something like a
56251 * two-dimensional array. Each row corresponds to a type (there are the same
56252 * number of rows as there are in the swig_type_initial array). Each entry in
56253 * a column is one of the swig_cast_info structures for that type.
56254 * The cast_initial array is actually an array of arrays, because each row has
56255 * a variable number of columns. So to actually build the cast linked list,
56256 * we find the array of casts associated with the type, and loop through it
56257 * adding the casts to the list. The one last trick we need to do is making
56258 * sure the type pointer in the swig_cast_info struct is correct.
56259 *
56260 * First off, we lookup the cast->type name to see if it is already loaded.
56261 * There are three cases to handle:
56262 * 1) If the cast->type has already been loaded AND the type we are adding
56263 * casting info to has not been loaded (it is in this module), THEN we
56264 * replace the cast->type pointer with the type pointer that has already
56265 * been loaded.
56266 * 2) If BOTH types (the one we are adding casting info to, and the
56267 * cast->type) are loaded, THEN the cast info has already been loaded by
56268 * the previous module so we just ignore it.
56269 * 3) Finally, if cast->type has not already been loaded, then we add that
56270 * swig_cast_info to the linked list (because the cast->type) pointer will
56271 * be correct.
56272 * ----------------------------------------------------------------------------- */
56273
56274 #ifdef __cplusplus
56275 extern "C" {
56276 #if 0
56277 } /* c-mode */
56278 #endif
56279 #endif
56280
56281 #if 0
56282 #define SWIGRUNTIME_DEBUG
56283 #endif
56284
56285 SWIGRUNTIME void
56286 SWIG_InitializeModule(void *clientdata) {
56287 size_t i;
56288 swig_module_info *module_head;
56289 static int init_run = 0;
56290
56291 clientdata = clientdata;
56292
56293 if (init_run) return;
56294 init_run = 1;
56295
56296 /* Initialize the swig_module */
56297 swig_module.type_initial = swig_type_initial;
56298 swig_module.cast_initial = swig_cast_initial;
56299
56300 /* Try and load any already created modules */
56301 module_head = SWIG_GetModule(clientdata);
56302 if (module_head) {
56303 swig_module.next = module_head->next;
56304 module_head->next = &swig_module;
56305 } else {
56306 /* This is the first module loaded */
56307 swig_module.next = &swig_module;
56308 SWIG_SetModule(clientdata, &swig_module);
56309 }
56310
56311 /* Now work on filling in swig_module.types */
56312 #ifdef SWIGRUNTIME_DEBUG
56313 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56314 #endif
56315 for (i = 0; i < swig_module.size; ++i) {
56316 swig_type_info *type = 0;
56317 swig_type_info *ret;
56318 swig_cast_info *cast;
56319
56320 #ifdef SWIGRUNTIME_DEBUG
56321 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56322 #endif
56323
56324 /* if there is another module already loaded */
56325 if (swig_module.next != &swig_module) {
56326 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56327 }
56328 if (type) {
56329 /* Overwrite clientdata field */
56330 #ifdef SWIGRUNTIME_DEBUG
56331 printf("SWIG_InitializeModule: found type %s\n", type->name);
56332 #endif
56333 if (swig_module.type_initial[i]->clientdata) {
56334 type->clientdata = swig_module.type_initial[i]->clientdata;
56335 #ifdef SWIGRUNTIME_DEBUG
56336 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56337 #endif
56338 }
56339 } else {
56340 type = swig_module.type_initial[i];
56341 }
56342
56343 /* Insert casting types */
56344 cast = swig_module.cast_initial[i];
56345 while (cast->type) {
56346 /* Don't need to add information already in the list */
56347 ret = 0;
56348 #ifdef SWIGRUNTIME_DEBUG
56349 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56350 #endif
56351 if (swig_module.next != &swig_module) {
56352 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56353 #ifdef SWIGRUNTIME_DEBUG
56354 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56355 #endif
56356 }
56357 if (ret) {
56358 if (type == swig_module.type_initial[i]) {
56359 #ifdef SWIGRUNTIME_DEBUG
56360 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56361 #endif
56362 cast->type = ret;
56363 ret = 0;
56364 } else {
56365 /* Check for casting already in the list */
56366 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56367 #ifdef SWIGRUNTIME_DEBUG
56368 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56369 #endif
56370 if (!ocast) ret = 0;
56371 }
56372 }
56373
56374 if (!ret) {
56375 #ifdef SWIGRUNTIME_DEBUG
56376 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56377 #endif
56378 if (type->cast) {
56379 type->cast->prev = cast;
56380 cast->next = type->cast;
56381 }
56382 type->cast = cast;
56383 }
56384 cast++;
56385 }
56386 /* Set entry in modules->types array equal to the type */
56387 swig_module.types[i] = type;
56388 }
56389 swig_module.types[i] = 0;
56390
56391 #ifdef SWIGRUNTIME_DEBUG
56392 printf("**** SWIG_InitializeModule: Cast List ******\n");
56393 for (i = 0; i < swig_module.size; ++i) {
56394 int j = 0;
56395 swig_cast_info *cast = swig_module.cast_initial[i];
56396 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56397 while (cast->type) {
56398 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56399 cast++;
56400 ++j;
56401 }
56402 printf("---- Total casts: %d\n",j);
56403 }
56404 printf("**** SWIG_InitializeModule: Cast List ******\n");
56405 #endif
56406 }
56407
56408 /* This function will propagate the clientdata field of type to
56409 * any new swig_type_info structures that have been added into the list
56410 * of equivalent types. It is like calling
56411 * SWIG_TypeClientData(type, clientdata) a second time.
56412 */
56413 SWIGRUNTIME void
56414 SWIG_PropagateClientData(void) {
56415 size_t i;
56416 swig_cast_info *equiv;
56417 static int init_run = 0;
56418
56419 if (init_run) return;
56420 init_run = 1;
56421
56422 for (i = 0; i < swig_module.size; i++) {
56423 if (swig_module.types[i]->clientdata) {
56424 equiv = swig_module.types[i]->cast;
56425 while (equiv) {
56426 if (!equiv->converter) {
56427 if (equiv->type && !equiv->type->clientdata)
56428 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56429 }
56430 equiv = equiv->next;
56431 }
56432 }
56433 }
56434 }
56435
56436 #ifdef __cplusplus
56437 #if 0
56438 {
56439 /* c-mode */
56440 #endif
56441 }
56442 #endif
56443
56444
56445
56446 #ifdef __cplusplus
56447 extern "C" {
56448 #endif
56449
56450 /* Python-specific SWIG API */
56451 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56452 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56453 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56454
56455 /* -----------------------------------------------------------------------------
56456 * global variable support code.
56457 * ----------------------------------------------------------------------------- */
56458
56459 typedef struct swig_globalvar {
56460 char *name; /* Name of global variable */
56461 PyObject *(*get_attr)(void); /* Return the current value */
56462 int (*set_attr)(PyObject *); /* Set the value */
56463 struct swig_globalvar *next;
56464 } swig_globalvar;
56465
56466 typedef struct swig_varlinkobject {
56467 PyObject_HEAD
56468 swig_globalvar *vars;
56469 } swig_varlinkobject;
56470
56471 SWIGINTERN PyObject *
56472 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56473 return PyString_FromString("<Swig global variables>");
56474 }
56475
56476 SWIGINTERN PyObject *
56477 swig_varlink_str(swig_varlinkobject *v) {
56478 PyObject *str = PyString_FromString("(");
56479 swig_globalvar *var;
56480 for (var = v->vars; var; var=var->next) {
56481 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56482 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56483 }
56484 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56485 return str;
56486 }
56487
56488 SWIGINTERN int
56489 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56490 PyObject *str = swig_varlink_str(v);
56491 fprintf(fp,"Swig global variables ");
56492 fprintf(fp,"%s\n", PyString_AsString(str));
56493 Py_DECREF(str);
56494 return 0;
56495 }
56496
56497 SWIGINTERN void
56498 swig_varlink_dealloc(swig_varlinkobject *v) {
56499 swig_globalvar *var = v->vars;
56500 while (var) {
56501 swig_globalvar *n = var->next;
56502 free(var->name);
56503 free(var);
56504 var = n;
56505 }
56506 }
56507
56508 SWIGINTERN PyObject *
56509 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56510 PyObject *res = NULL;
56511 swig_globalvar *var = v->vars;
56512 while (var) {
56513 if (strcmp(var->name,n) == 0) {
56514 res = (*var->get_attr)();
56515 break;
56516 }
56517 var = var->next;
56518 }
56519 if (res == NULL && !PyErr_Occurred()) {
56520 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56521 }
56522 return res;
56523 }
56524
56525 SWIGINTERN int
56526 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
56527 int res = 1;
56528 swig_globalvar *var = v->vars;
56529 while (var) {
56530 if (strcmp(var->name,n) == 0) {
56531 res = (*var->set_attr)(p);
56532 break;
56533 }
56534 var = var->next;
56535 }
56536 if (res == 1 && !PyErr_Occurred()) {
56537 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56538 }
56539 return res;
56540 }
56541
56542 SWIGINTERN PyTypeObject*
56543 swig_varlink_type(void) {
56544 static char varlink__doc__[] = "Swig var link object";
56545 static PyTypeObject varlink_type;
56546 static int type_init = 0;
56547 if (!type_init) {
56548 const PyTypeObject tmp
56549 = {
56550 PyObject_HEAD_INIT(NULL)
56551 0, /* Number of items in variable part (ob_size) */
56552 (char *)"swigvarlink", /* Type name (tp_name) */
56553 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
56554 0, /* Itemsize (tp_itemsize) */
56555 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
56556 (printfunc) swig_varlink_print, /* Print (tp_print) */
56557 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
56558 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
56559 0, /* tp_compare */
56560 (reprfunc) swig_varlink_repr, /* tp_repr */
56561 0, /* tp_as_number */
56562 0, /* tp_as_sequence */
56563 0, /* tp_as_mapping */
56564 0, /* tp_hash */
56565 0, /* tp_call */
56566 (reprfunc)swig_varlink_str, /* tp_str */
56567 0, /* tp_getattro */
56568 0, /* tp_setattro */
56569 0, /* tp_as_buffer */
56570 0, /* tp_flags */
56571 varlink__doc__, /* tp_doc */
56572 0, /* tp_traverse */
56573 0, /* tp_clear */
56574 0, /* tp_richcompare */
56575 0, /* tp_weaklistoffset */
56576 #if PY_VERSION_HEX >= 0x02020000
56577 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
56578 #endif
56579 #if PY_VERSION_HEX >= 0x02030000
56580 0, /* tp_del */
56581 #endif
56582 #ifdef COUNT_ALLOCS
56583 0,0,0,0 /* tp_alloc -> tp_next */
56584 #endif
56585 };
56586 varlink_type = tmp;
56587 varlink_type.ob_type = &PyType_Type;
56588 type_init = 1;
56589 }
56590 return &varlink_type;
56591 }
56592
56593 /* Create a variable linking object for use later */
56594 SWIGINTERN PyObject *
56595 SWIG_Python_newvarlink(void) {
56596 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
56597 if (result) {
56598 result->vars = 0;
56599 }
56600 return ((PyObject*) result);
56601 }
56602
56603 SWIGINTERN void
56604 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
56605 swig_varlinkobject *v = (swig_varlinkobject *) p;
56606 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
56607 if (gv) {
56608 size_t size = strlen(name)+1;
56609 gv->name = (char *)malloc(size);
56610 if (gv->name) {
56611 strncpy(gv->name,name,size);
56612 gv->get_attr = get_attr;
56613 gv->set_attr = set_attr;
56614 gv->next = v->vars;
56615 }
56616 }
56617 v->vars = gv;
56618 }
56619
56620 SWIGINTERN PyObject *
56621 SWIG_globals() {
56622 static PyObject *_SWIG_globals = 0;
56623 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56624 return _SWIG_globals;
56625 }
56626
56627 /* -----------------------------------------------------------------------------
56628 * constants/methods manipulation
56629 * ----------------------------------------------------------------------------- */
56630
56631 /* Install Constants */
56632 SWIGINTERN void
56633 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56634 PyObject *obj = 0;
56635 size_t i;
56636 for (i = 0; constants[i].type; ++i) {
56637 switch(constants[i].type) {
56638 case SWIG_PY_POINTER:
56639 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56640 break;
56641 case SWIG_PY_BINARY:
56642 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56643 break;
56644 default:
56645 obj = 0;
56646 break;
56647 }
56648 if (obj) {
56649 PyDict_SetItemString(d, constants[i].name, obj);
56650 Py_DECREF(obj);
56651 }
56652 }
56653 }
56654
56655 /* -----------------------------------------------------------------------------*/
56656 /* Fix SwigMethods to carry the callback ptrs when needed */
56657 /* -----------------------------------------------------------------------------*/
56658
56659 SWIGINTERN void
56660 SWIG_Python_FixMethods(PyMethodDef *methods,
56661 swig_const_info *const_table,
56662 swig_type_info **types,
56663 swig_type_info **types_initial) {
56664 size_t i;
56665 for (i = 0; methods[i].ml_name; ++i) {
56666 const char *c = methods[i].ml_doc;
56667 if (c && (c = strstr(c, "swig_ptr: "))) {
56668 int j;
56669 swig_const_info *ci = 0;
56670 const char *name = c + 10;
56671 for (j = 0; const_table[j].type; ++j) {
56672 if (strncmp(const_table[j].name, name,
56673 strlen(const_table[j].name)) == 0) {
56674 ci = &(const_table[j]);
56675 break;
56676 }
56677 }
56678 if (ci) {
56679 size_t shift = (ci->ptype) - types;
56680 swig_type_info *ty = types_initial[shift];
56681 size_t ldoc = (c - methods[i].ml_doc);
56682 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56683 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56684 if (ndoc) {
56685 char *buff = ndoc;
56686 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56687 if (ptr) {
56688 strncpy(buff, methods[i].ml_doc, ldoc);
56689 buff += ldoc;
56690 strncpy(buff, "swig_ptr: ", 10);
56691 buff += 10;
56692 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56693 methods[i].ml_doc = ndoc;
56694 }
56695 }
56696 }
56697 }
56698 }
56699 }
56700
56701 #ifdef __cplusplus
56702 }
56703 #endif
56704
56705 /* -----------------------------------------------------------------------------*
56706 * Partial Init method
56707 * -----------------------------------------------------------------------------*/
56708
56709 #ifdef __cplusplus
56710 extern "C"
56711 #endif
56712 SWIGEXPORT void SWIG_init(void) {
56713 PyObject *m, *d;
56714
56715 /* Fix SwigMethods to carry the callback ptrs when needed */
56716 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56717
56718 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56719 d = PyModule_GetDict(m);
56720
56721 SWIG_InitializeModule(0);
56722 SWIG_InstallConstants(d,swig_const_table);
56723
56724
56725
56726 #ifndef wxPyUSE_EXPORT
56727 // Make our API structure a CObject so other modules can import it
56728 // from this module.
56729 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56730 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56731 Py_XDECREF(cobj);
56732 #endif
56733
56734 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56735 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56736 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56737 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56738 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56739 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56740 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56741 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56742 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56743 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56744 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56745 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56746 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56747 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56748 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56749 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56750 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56751 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56752 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56753 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56754 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56755 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56756 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56757 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56758 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56759 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56760 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56761 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56762 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56763 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56764 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56765 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56766 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56767 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56768 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56769 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56770 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56771 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56772 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56773 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56774 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56775 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56776 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56777 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56778 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56779 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56780 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56781 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56782 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56783 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56784 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56785 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56786 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56787 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56788 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56789 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56790 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56791 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56792 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56793 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56794 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56795 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56796 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56797 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56798 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56799 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56800 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56801 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56802 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56803 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56804 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56805 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56806 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56807 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56808 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56809 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56810 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56811 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56812 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56813 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56814 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56815 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56816 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56817 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56818 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56819 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56820 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56821 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56822 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56823 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56824 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56825 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56826 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56827 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56828 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56829 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56830 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56831 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56832 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56833 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56834 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56835 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56836 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56837 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56838 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56839 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56840 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56841 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56842 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56843 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56844 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56845 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56846 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56847 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56848 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56849 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56850 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56851 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56852 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56853 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56854 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56855 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56856 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56857 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56858 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56859 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
56860 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56861 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56862 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56863 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56864 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56865 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56866 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56867 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56868 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56869 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56870 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56871 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56872 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56873 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56874 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56875 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56876 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56877 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56878 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56879 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
56880 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56881 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56882 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56883 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56884 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56885 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56886 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56887 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56888 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56889 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56890 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56891 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56892 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56893 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56894 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56895 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56896 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56897 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56898 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56899 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56900 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56901 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56902 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56903 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56904 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56905 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56906 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56907 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56908 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56909 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56910 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56911 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56912 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56913 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56914 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56915 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56916 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56917 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56918 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56919 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56920 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56921 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56922 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56923 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56924 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56925 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56926 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56927 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56928 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56929 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56930 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56931 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56932 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56933 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56934 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56935 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56936 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56937 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56938 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56939 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56940 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56941 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56942 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56943 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56944 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56945 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56946 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56947 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56948 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56949 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56950 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56951 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56952 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56953 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56954 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56955 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56956 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56957 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56958 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56959 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56960 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56961 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56962 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56963 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56964 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56965 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56966 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56967 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56968 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56969 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56970 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56971 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56972 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56973 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56974 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56975 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56976 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56977 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56978 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56979 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56980 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56981 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56982 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56983 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56984 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56985 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56986 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56987 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56988 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56989 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56990 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56991 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56992 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56993 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56994 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56995 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56996 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56997 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56998 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56999 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57000 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57001 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57002 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57003 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57004 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57005 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57006 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57007 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57008 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57009 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57010 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57011 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57012 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57013 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57014 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57015 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57016 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57017 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57018 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57019 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57020 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57021 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57022 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57023 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57024 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57025 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57026 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57027 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57028 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57029 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57030 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57031 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57032 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57033 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57034 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57035 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57036 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57037 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57038 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57039 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57040 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57041 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57042 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57043 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57044 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57045 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57046 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57047 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57048 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57049 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57050 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57051 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57052 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57053 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57054 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57055 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57056 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57057 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57058 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57059 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57060 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57061 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57062 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57063 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57064 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57065 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57066 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57067 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57068 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57069 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57070 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57071 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57072 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57073 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57074 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57075 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57076 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57077 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57078 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57079 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57080 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57081 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57082 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57083 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57084 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57085 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57086 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57087 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57088 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57089 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57090 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57091 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57092 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57093 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57094 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57095 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57096 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57097 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57098 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57099 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57100 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57101 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57102 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57103 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57104 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57105 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57106 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57107 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57108 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57109 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57110 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57111 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57112 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57113 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57114 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57115 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57116 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57117 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57118 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57119 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57120 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57121 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57122 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57123 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57124 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57125 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57126 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57127 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57128 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57129 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57130 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57131 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57132 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57133 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57134 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57135 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57136 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57137 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57138 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57139 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57140 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57141 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57142 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57143 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57144 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57145 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57146 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57147 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57148 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57149 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57150 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57151 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57152 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57153 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57154 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57155 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57156 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57157 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57158 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57159 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57160 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57161 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57162 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57163 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57164 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57165 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57166 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57167 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57168 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57169 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57170 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57171 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57172 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57173 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57174 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57175 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57176 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57177 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57178 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57179 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57180 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57181 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57182 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57183 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57184 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57185 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57186 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57187 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57188 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57189 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57190 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57191 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57192 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57193 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57194 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57195 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57196 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57197 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57198 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57199 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57200 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57201 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57202 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57203 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57204 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57205 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57206 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57207 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57208 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57209 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57210 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57211 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57212 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57213 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57214 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57215 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57216 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57217 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57218 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57219 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57220 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57221 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57222 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57223 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57224 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57225 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57226 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57227 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57228 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57229 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57230 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57231 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57232 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57233 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57234 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57235 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57236 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57237 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57238 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57239 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57240 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57241 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57242 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57243 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57244 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57245 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57246 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57247 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57248 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57249 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57250 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57251 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57252 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57253 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57254 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57255 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57256 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57257 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57258 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57259 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57260 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57261 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57262 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57263 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57264 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57265 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57266 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57267 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57268 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57269 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57270 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57271 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57272 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57273 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57274 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57275 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57276 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57277 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57278 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57279 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57280 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57281 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57282 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57283 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57284 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57285 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57286 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57287 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57288 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57289 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57290 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57291 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57292 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57293 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57294 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57295 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57296 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57297 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57298 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57299 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57300 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57301 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57302 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57303 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57304 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57305 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57306 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57307 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57308 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57309 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57310 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57311 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57312 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57313 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57314 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57315 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57316 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57317 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57318 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57319 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57320 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57321 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57322 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57323 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57324 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57325 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57326 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57327 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57328 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57329 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57330 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57331 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57332 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57333 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57334 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57335 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57336 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57337 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57338 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57339 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57340 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57341 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57342 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57343 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57344 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57345 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57346 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57347 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57348 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57349 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57350 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57351 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57352 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57353 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57354 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57355 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57356 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57357 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57358 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57359 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57360 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57361 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57362 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57363 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57364 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57365 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57366 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57367 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57368 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57369 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57370 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57371 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57372 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57373 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57374 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57375 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57376 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57377 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57378 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57379 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57380 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57381 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57382 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57383 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57384 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57385 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57386 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57387 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57388 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57389 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57390 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57391 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57392 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57393 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57394 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57395 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57396 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57397 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57398
57399 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57400
57401
57402 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57403
57404 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57405 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57406 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57407 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57408 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57409 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57410 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57411 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57412 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57413 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57414 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57415 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57416 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57417 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57418 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57419 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57420 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57421 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57422 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57423 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57424 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57425 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57426 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57427 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57428 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57429 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57430 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57431 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57432 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57433 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57434 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57435 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57436 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57437 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57438 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57439 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57440 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57441 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57442 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57443 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57444 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57445 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57446 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57447 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57448 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57449 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57450 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57451 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57452 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57453 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57454 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57455 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57456 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57457 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57458 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57459 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57460 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57461 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57462 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57463 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57464 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57465 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57466 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57467 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57468 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57469 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57470 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57471 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57472 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57473 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57474 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57475 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57476 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57477 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57478 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57479 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57480 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57481 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57482 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57483 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57484 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57485 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57486 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57487 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57488 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57489 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57490 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57491 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57492 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57493 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57494 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57495 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57496 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57497 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57498 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57499 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57500 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57501 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57502 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57503 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57504 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57505 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57506 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57507 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57508 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57509 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57510 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57511 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57512 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57513 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57514 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57515 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57516 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57517 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57518 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57519 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57520 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57521 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
57522 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
57523 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
57524 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
57525 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
57526 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
57527 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
57528 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
57529 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
57530 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
57531 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
57532 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
57533 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
57534 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
57535 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
57536 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
57537 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
57538 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
57539 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
57540 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
57541 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
57542 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
57543 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
57544 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
57545 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
57546 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
57547 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
57548 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
57549 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
57550 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
57551 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
57552 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
57553 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
57554 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
57555 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
57556 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
57557 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
57558 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
57559 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
57560 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
57561 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
57562 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
57563 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
57564 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
57565 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
57566 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
57567 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
57568 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
57569 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
57570 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
57571 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
57572 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
57573 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
57574 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
57575 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
57576 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
57577 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
57578 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
57579 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
57580 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
57581 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
57582 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
57583 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
57584 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
57585 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
57586 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
57587 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
57588 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
57589 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
57590 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
57591 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
57592 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
57593 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
57594 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
57595 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
57596 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
57597 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
57598 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
57599 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
57600 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
57601 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
57602 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
57603 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
57604 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
57605 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
57606 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
57607 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
57608 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
57609 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57610 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57611 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57612 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57613 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57614 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57615 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57616
57617 // Initialize threading, some globals and such
57618 __wxPyPreStart(d);
57619
57620
57621 // Although these are defined in __version__ they need to be here too so
57622 // that an assert can be done to ensure that the wxPython and the wxWindows
57623 // versions match.
57624 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57625 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57626 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57627
57628 }
57629
wxWidgets (Impactor)