]> 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
added Bryan's new icons
[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_IsDisplayAvailable(){
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_ContainsXY(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_ContainsXY",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_ContainsXY" "', 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_ContainsXY" "', 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_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7528 }
7529 arg3 = static_cast< int >(val3);
7530 {
7531 PyThreadState* __tstate = wxPyBeginAllowThreads();
7532 result = (bool)((wxRect const *)arg1)->Contains(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_Contains(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_Contains",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_Contains" "', 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)->Contains((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_ContainsRect(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_ContainsRect",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_ContainsRect" "', 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)->Contains((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_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28633 PyObject *resultobj = 0;
28634 bool result;
28635
28636 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
28637 {
28638 PyThreadState* __tstate = wxPyBeginAllowThreads();
28639 result = (bool)wxPyApp_IsDisplayAvailable();
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_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33011 PyObject *resultobj = 0;
33012 wxWindow *arg1 = (wxWindow *) 0 ;
33013 bool result;
33014 void *argp1 = 0 ;
33015 int res1 = 0 ;
33016 PyObject *swig_obj[1] ;
33017
33018 if (!args) SWIG_fail;
33019 swig_obj[0] = args;
33020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33021 if (!SWIG_IsOK(res1)) {
33022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
33023 }
33024 arg1 = reinterpret_cast< wxWindow * >(argp1);
33025 {
33026 PyThreadState* __tstate = wxPyBeginAllowThreads();
33027 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
33028 wxPyEndAllowThreads(__tstate);
33029 if (PyErr_Occurred()) SWIG_fail;
33030 }
33031 {
33032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33033 }
33034 return resultobj;
33035 fail:
33036 return NULL;
33037 }
33038
33039
33040 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33041 PyObject *resultobj = 0;
33042 wxWindow *arg1 = (wxWindow *) 0 ;
33043 long arg2 ;
33044 void *argp1 = 0 ;
33045 int res1 = 0 ;
33046 long val2 ;
33047 int ecode2 = 0 ;
33048 PyObject * obj0 = 0 ;
33049 PyObject * obj1 = 0 ;
33050 char * kwnames[] = {
33051 (char *) "self",(char *) "style", NULL
33052 };
33053
33054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33056 if (!SWIG_IsOK(res1)) {
33057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
33058 }
33059 arg1 = reinterpret_cast< wxWindow * >(argp1);
33060 ecode2 = SWIG_AsVal_long(obj1, &val2);
33061 if (!SWIG_IsOK(ecode2)) {
33062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
33063 }
33064 arg2 = static_cast< long >(val2);
33065 {
33066 PyThreadState* __tstate = wxPyBeginAllowThreads();
33067 (arg1)->SetWindowStyleFlag(arg2);
33068 wxPyEndAllowThreads(__tstate);
33069 if (PyErr_Occurred()) SWIG_fail;
33070 }
33071 resultobj = SWIG_Py_Void();
33072 return resultobj;
33073 fail:
33074 return NULL;
33075 }
33076
33077
33078 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33079 PyObject *resultobj = 0;
33080 wxWindow *arg1 = (wxWindow *) 0 ;
33081 long result;
33082 void *argp1 = 0 ;
33083 int res1 = 0 ;
33084 PyObject *swig_obj[1] ;
33085
33086 if (!args) SWIG_fail;
33087 swig_obj[0] = args;
33088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33089 if (!SWIG_IsOK(res1)) {
33090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33091 }
33092 arg1 = reinterpret_cast< wxWindow * >(argp1);
33093 {
33094 PyThreadState* __tstate = wxPyBeginAllowThreads();
33095 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
33096 wxPyEndAllowThreads(__tstate);
33097 if (PyErr_Occurred()) SWIG_fail;
33098 }
33099 resultobj = SWIG_From_long(static_cast< long >(result));
33100 return resultobj;
33101 fail:
33102 return NULL;
33103 }
33104
33105
33106 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33107 PyObject *resultobj = 0;
33108 wxWindow *arg1 = (wxWindow *) 0 ;
33109 int arg2 ;
33110 bool result;
33111 void *argp1 = 0 ;
33112 int res1 = 0 ;
33113 int val2 ;
33114 int ecode2 = 0 ;
33115 PyObject * obj0 = 0 ;
33116 PyObject * obj1 = 0 ;
33117 char * kwnames[] = {
33118 (char *) "self",(char *) "flag", NULL
33119 };
33120
33121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
33122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33123 if (!SWIG_IsOK(res1)) {
33124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
33125 }
33126 arg1 = reinterpret_cast< wxWindow * >(argp1);
33127 ecode2 = SWIG_AsVal_int(obj1, &val2);
33128 if (!SWIG_IsOK(ecode2)) {
33129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
33130 }
33131 arg2 = static_cast< int >(val2);
33132 {
33133 PyThreadState* __tstate = wxPyBeginAllowThreads();
33134 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
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_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33148 PyObject *resultobj = 0;
33149 wxWindow *arg1 = (wxWindow *) 0 ;
33150 bool result;
33151 void *argp1 = 0 ;
33152 int res1 = 0 ;
33153 PyObject *swig_obj[1] ;
33154
33155 if (!args) SWIG_fail;
33156 swig_obj[0] = args;
33157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33158 if (!SWIG_IsOK(res1)) {
33159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
33160 }
33161 arg1 = reinterpret_cast< wxWindow * >(argp1);
33162 {
33163 PyThreadState* __tstate = wxPyBeginAllowThreads();
33164 result = (bool)((wxWindow const *)arg1)->IsRetained();
33165 wxPyEndAllowThreads(__tstate);
33166 if (PyErr_Occurred()) SWIG_fail;
33167 }
33168 {
33169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33170 }
33171 return resultobj;
33172 fail:
33173 return NULL;
33174 }
33175
33176
33177 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33178 PyObject *resultobj = 0;
33179 wxWindow *arg1 = (wxWindow *) 0 ;
33180 long arg2 ;
33181 void *argp1 = 0 ;
33182 int res1 = 0 ;
33183 long val2 ;
33184 int ecode2 = 0 ;
33185 PyObject * obj0 = 0 ;
33186 PyObject * obj1 = 0 ;
33187 char * kwnames[] = {
33188 (char *) "self",(char *) "exStyle", NULL
33189 };
33190
33191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
33192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33193 if (!SWIG_IsOK(res1)) {
33194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
33195 }
33196 arg1 = reinterpret_cast< wxWindow * >(argp1);
33197 ecode2 = SWIG_AsVal_long(obj1, &val2);
33198 if (!SWIG_IsOK(ecode2)) {
33199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
33200 }
33201 arg2 = static_cast< long >(val2);
33202 {
33203 PyThreadState* __tstate = wxPyBeginAllowThreads();
33204 (arg1)->SetExtraStyle(arg2);
33205 wxPyEndAllowThreads(__tstate);
33206 if (PyErr_Occurred()) SWIG_fail;
33207 }
33208 resultobj = SWIG_Py_Void();
33209 return resultobj;
33210 fail:
33211 return NULL;
33212 }
33213
33214
33215 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33216 PyObject *resultobj = 0;
33217 wxWindow *arg1 = (wxWindow *) 0 ;
33218 long result;
33219 void *argp1 = 0 ;
33220 int res1 = 0 ;
33221 PyObject *swig_obj[1] ;
33222
33223 if (!args) SWIG_fail;
33224 swig_obj[0] = args;
33225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33226 if (!SWIG_IsOK(res1)) {
33227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
33228 }
33229 arg1 = reinterpret_cast< wxWindow * >(argp1);
33230 {
33231 PyThreadState* __tstate = wxPyBeginAllowThreads();
33232 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
33233 wxPyEndAllowThreads(__tstate);
33234 if (PyErr_Occurred()) SWIG_fail;
33235 }
33236 resultobj = SWIG_From_long(static_cast< long >(result));
33237 return resultobj;
33238 fail:
33239 return NULL;
33240 }
33241
33242
33243 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33244 PyObject *resultobj = 0;
33245 wxWindow *arg1 = (wxWindow *) 0 ;
33246 bool arg2 = (bool) true ;
33247 void *argp1 = 0 ;
33248 int res1 = 0 ;
33249 bool val2 ;
33250 int ecode2 = 0 ;
33251 PyObject * obj0 = 0 ;
33252 PyObject * obj1 = 0 ;
33253 char * kwnames[] = {
33254 (char *) "self",(char *) "modal", NULL
33255 };
33256
33257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
33258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33259 if (!SWIG_IsOK(res1)) {
33260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
33261 }
33262 arg1 = reinterpret_cast< wxWindow * >(argp1);
33263 if (obj1) {
33264 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33265 if (!SWIG_IsOK(ecode2)) {
33266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
33267 }
33268 arg2 = static_cast< bool >(val2);
33269 }
33270 {
33271 PyThreadState* __tstate = wxPyBeginAllowThreads();
33272 (arg1)->MakeModal(arg2);
33273 wxPyEndAllowThreads(__tstate);
33274 if (PyErr_Occurred()) SWIG_fail;
33275 }
33276 resultobj = SWIG_Py_Void();
33277 return resultobj;
33278 fail:
33279 return NULL;
33280 }
33281
33282
33283 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33284 PyObject *resultobj = 0;
33285 wxWindow *arg1 = (wxWindow *) 0 ;
33286 bool arg2 ;
33287 void *argp1 = 0 ;
33288 int res1 = 0 ;
33289 bool val2 ;
33290 int ecode2 = 0 ;
33291 PyObject * obj0 = 0 ;
33292 PyObject * obj1 = 0 ;
33293 char * kwnames[] = {
33294 (char *) "self",(char *) "enableTheme", NULL
33295 };
33296
33297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
33298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33299 if (!SWIG_IsOK(res1)) {
33300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
33301 }
33302 arg1 = reinterpret_cast< wxWindow * >(argp1);
33303 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33304 if (!SWIG_IsOK(ecode2)) {
33305 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
33306 }
33307 arg2 = static_cast< bool >(val2);
33308 {
33309 PyThreadState* __tstate = wxPyBeginAllowThreads();
33310 (arg1)->SetThemeEnabled(arg2);
33311 wxPyEndAllowThreads(__tstate);
33312 if (PyErr_Occurred()) SWIG_fail;
33313 }
33314 resultobj = SWIG_Py_Void();
33315 return resultobj;
33316 fail:
33317 return NULL;
33318 }
33319
33320
33321 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33322 PyObject *resultobj = 0;
33323 wxWindow *arg1 = (wxWindow *) 0 ;
33324 bool result;
33325 void *argp1 = 0 ;
33326 int res1 = 0 ;
33327 PyObject *swig_obj[1] ;
33328
33329 if (!args) SWIG_fail;
33330 swig_obj[0] = args;
33331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33332 if (!SWIG_IsOK(res1)) {
33333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
33334 }
33335 arg1 = reinterpret_cast< wxWindow * >(argp1);
33336 {
33337 PyThreadState* __tstate = wxPyBeginAllowThreads();
33338 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
33339 wxPyEndAllowThreads(__tstate);
33340 if (PyErr_Occurred()) SWIG_fail;
33341 }
33342 {
33343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33344 }
33345 return resultobj;
33346 fail:
33347 return NULL;
33348 }
33349
33350
33351 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33352 PyObject *resultobj = 0;
33353 wxWindow *arg1 = (wxWindow *) 0 ;
33354 void *argp1 = 0 ;
33355 int res1 = 0 ;
33356 PyObject *swig_obj[1] ;
33357
33358 if (!args) SWIG_fail;
33359 swig_obj[0] = args;
33360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33361 if (!SWIG_IsOK(res1)) {
33362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
33363 }
33364 arg1 = reinterpret_cast< wxWindow * >(argp1);
33365 {
33366 PyThreadState* __tstate = wxPyBeginAllowThreads();
33367 (arg1)->SetFocus();
33368 wxPyEndAllowThreads(__tstate);
33369 if (PyErr_Occurred()) SWIG_fail;
33370 }
33371 resultobj = SWIG_Py_Void();
33372 return resultobj;
33373 fail:
33374 return NULL;
33375 }
33376
33377
33378 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33379 PyObject *resultobj = 0;
33380 wxWindow *arg1 = (wxWindow *) 0 ;
33381 void *argp1 = 0 ;
33382 int res1 = 0 ;
33383 PyObject *swig_obj[1] ;
33384
33385 if (!args) SWIG_fail;
33386 swig_obj[0] = args;
33387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33388 if (!SWIG_IsOK(res1)) {
33389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
33390 }
33391 arg1 = reinterpret_cast< wxWindow * >(argp1);
33392 {
33393 PyThreadState* __tstate = wxPyBeginAllowThreads();
33394 (arg1)->SetFocusFromKbd();
33395 wxPyEndAllowThreads(__tstate);
33396 if (PyErr_Occurred()) SWIG_fail;
33397 }
33398 resultobj = SWIG_Py_Void();
33399 return resultobj;
33400 fail:
33401 return NULL;
33402 }
33403
33404
33405 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33406 PyObject *resultobj = 0;
33407 wxWindow *result = 0 ;
33408
33409 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
33410 {
33411 if (!wxPyCheckForApp()) SWIG_fail;
33412 PyThreadState* __tstate = wxPyBeginAllowThreads();
33413 result = (wxWindow *)wxWindow::FindFocus();
33414 wxPyEndAllowThreads(__tstate);
33415 if (PyErr_Occurred()) SWIG_fail;
33416 }
33417 {
33418 resultobj = wxPyMake_wxObject(result, 0);
33419 }
33420 return resultobj;
33421 fail:
33422 return NULL;
33423 }
33424
33425
33426 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(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_AcceptsFocus" "', 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)->AcceptsFocus();
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_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33457 PyObject *resultobj = 0;
33458 wxWindow *arg1 = (wxWindow *) 0 ;
33459 bool result;
33460 void *argp1 = 0 ;
33461 int res1 = 0 ;
33462 PyObject *swig_obj[1] ;
33463
33464 if (!args) SWIG_fail;
33465 swig_obj[0] = args;
33466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33467 if (!SWIG_IsOK(res1)) {
33468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
33469 }
33470 arg1 = reinterpret_cast< wxWindow * >(argp1);
33471 {
33472 PyThreadState* __tstate = wxPyBeginAllowThreads();
33473 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
33474 wxPyEndAllowThreads(__tstate);
33475 if (PyErr_Occurred()) SWIG_fail;
33476 }
33477 {
33478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33479 }
33480 return resultobj;
33481 fail:
33482 return NULL;
33483 }
33484
33485
33486 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33487 PyObject *resultobj = 0;
33488 wxWindow *arg1 = (wxWindow *) 0 ;
33489 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
33490 bool result;
33491 void *argp1 = 0 ;
33492 int res1 = 0 ;
33493 int val2 ;
33494 int ecode2 = 0 ;
33495 PyObject * obj0 = 0 ;
33496 PyObject * obj1 = 0 ;
33497 char * kwnames[] = {
33498 (char *) "self",(char *) "flags", NULL
33499 };
33500
33501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
33502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33503 if (!SWIG_IsOK(res1)) {
33504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
33505 }
33506 arg1 = reinterpret_cast< wxWindow * >(argp1);
33507 if (obj1) {
33508 ecode2 = SWIG_AsVal_int(obj1, &val2);
33509 if (!SWIG_IsOK(ecode2)) {
33510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
33511 }
33512 arg2 = static_cast< int >(val2);
33513 }
33514 {
33515 PyThreadState* __tstate = wxPyBeginAllowThreads();
33516 result = (bool)(arg1)->Navigate(arg2);
33517 wxPyEndAllowThreads(__tstate);
33518 if (PyErr_Occurred()) SWIG_fail;
33519 }
33520 {
33521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33522 }
33523 return resultobj;
33524 fail:
33525 return NULL;
33526 }
33527
33528
33529 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33530 PyObject *resultobj = 0;
33531 wxWindow *arg1 = (wxWindow *) 0 ;
33532 wxWindow *arg2 = (wxWindow *) 0 ;
33533 void *argp1 = 0 ;
33534 int res1 = 0 ;
33535 void *argp2 = 0 ;
33536 int res2 = 0 ;
33537 PyObject * obj0 = 0 ;
33538 PyObject * obj1 = 0 ;
33539 char * kwnames[] = {
33540 (char *) "self",(char *) "win", NULL
33541 };
33542
33543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33545 if (!SWIG_IsOK(res1)) {
33546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33547 }
33548 arg1 = reinterpret_cast< wxWindow * >(argp1);
33549 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33550 if (!SWIG_IsOK(res2)) {
33551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33552 }
33553 arg2 = reinterpret_cast< wxWindow * >(argp2);
33554 {
33555 PyThreadState* __tstate = wxPyBeginAllowThreads();
33556 (arg1)->MoveAfterInTabOrder(arg2);
33557 wxPyEndAllowThreads(__tstate);
33558 if (PyErr_Occurred()) SWIG_fail;
33559 }
33560 resultobj = SWIG_Py_Void();
33561 return resultobj;
33562 fail:
33563 return NULL;
33564 }
33565
33566
33567 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33568 PyObject *resultobj = 0;
33569 wxWindow *arg1 = (wxWindow *) 0 ;
33570 wxWindow *arg2 = (wxWindow *) 0 ;
33571 void *argp1 = 0 ;
33572 int res1 = 0 ;
33573 void *argp2 = 0 ;
33574 int res2 = 0 ;
33575 PyObject * obj0 = 0 ;
33576 PyObject * obj1 = 0 ;
33577 char * kwnames[] = {
33578 (char *) "self",(char *) "win", NULL
33579 };
33580
33581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33583 if (!SWIG_IsOK(res1)) {
33584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33585 }
33586 arg1 = reinterpret_cast< wxWindow * >(argp1);
33587 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33588 if (!SWIG_IsOK(res2)) {
33589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33590 }
33591 arg2 = reinterpret_cast< wxWindow * >(argp2);
33592 {
33593 PyThreadState* __tstate = wxPyBeginAllowThreads();
33594 (arg1)->MoveBeforeInTabOrder(arg2);
33595 wxPyEndAllowThreads(__tstate);
33596 if (PyErr_Occurred()) SWIG_fail;
33597 }
33598 resultobj = SWIG_Py_Void();
33599 return resultobj;
33600 fail:
33601 return NULL;
33602 }
33603
33604
33605 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33606 PyObject *resultobj = 0;
33607 wxWindow *arg1 = (wxWindow *) 0 ;
33608 PyObject *result = 0 ;
33609 void *argp1 = 0 ;
33610 int res1 = 0 ;
33611 PyObject *swig_obj[1] ;
33612
33613 if (!args) SWIG_fail;
33614 swig_obj[0] = args;
33615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33616 if (!SWIG_IsOK(res1)) {
33617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33618 }
33619 arg1 = reinterpret_cast< wxWindow * >(argp1);
33620 {
33621 PyThreadState* __tstate = wxPyBeginAllowThreads();
33622 result = (PyObject *)wxWindow_GetChildren(arg1);
33623 wxPyEndAllowThreads(__tstate);
33624 if (PyErr_Occurred()) SWIG_fail;
33625 }
33626 resultobj = result;
33627 return resultobj;
33628 fail:
33629 return NULL;
33630 }
33631
33632
33633 SWIGINTERN PyObject *_wrap_Window_GetParent(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_GetParent" "', 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)->GetParent();
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_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33664 PyObject *resultobj = 0;
33665 wxWindow *arg1 = (wxWindow *) 0 ;
33666 wxWindow *result = 0 ;
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_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33676 }
33677 arg1 = reinterpret_cast< wxWindow * >(argp1);
33678 {
33679 PyThreadState* __tstate = wxPyBeginAllowThreads();
33680 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33681 wxPyEndAllowThreads(__tstate);
33682 if (PyErr_Occurred()) SWIG_fail;
33683 }
33684 {
33685 resultobj = wxPyMake_wxObject(result, 0);
33686 }
33687 return resultobj;
33688 fail:
33689 return NULL;
33690 }
33691
33692
33693 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33694 PyObject *resultobj = 0;
33695 wxWindow *arg1 = (wxWindow *) 0 ;
33696 bool result;
33697 void *argp1 = 0 ;
33698 int res1 = 0 ;
33699 PyObject *swig_obj[1] ;
33700
33701 if (!args) SWIG_fail;
33702 swig_obj[0] = args;
33703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33704 if (!SWIG_IsOK(res1)) {
33705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33706 }
33707 arg1 = reinterpret_cast< wxWindow * >(argp1);
33708 {
33709 PyThreadState* __tstate = wxPyBeginAllowThreads();
33710 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33711 wxPyEndAllowThreads(__tstate);
33712 if (PyErr_Occurred()) SWIG_fail;
33713 }
33714 {
33715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33716 }
33717 return resultobj;
33718 fail:
33719 return NULL;
33720 }
33721
33722
33723 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33724 PyObject *resultobj = 0;
33725 wxWindow *arg1 = (wxWindow *) 0 ;
33726 wxWindow *arg2 = (wxWindow *) 0 ;
33727 bool result;
33728 void *argp1 = 0 ;
33729 int res1 = 0 ;
33730 void *argp2 = 0 ;
33731 int res2 = 0 ;
33732 PyObject * obj0 = 0 ;
33733 PyObject * obj1 = 0 ;
33734 char * kwnames[] = {
33735 (char *) "self",(char *) "newParent", NULL
33736 };
33737
33738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33740 if (!SWIG_IsOK(res1)) {
33741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33742 }
33743 arg1 = reinterpret_cast< wxWindow * >(argp1);
33744 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33745 if (!SWIG_IsOK(res2)) {
33746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33747 }
33748 arg2 = reinterpret_cast< wxWindow * >(argp2);
33749 {
33750 PyThreadState* __tstate = wxPyBeginAllowThreads();
33751 result = (bool)(arg1)->Reparent(arg2);
33752 wxPyEndAllowThreads(__tstate);
33753 if (PyErr_Occurred()) SWIG_fail;
33754 }
33755 {
33756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33757 }
33758 return resultobj;
33759 fail:
33760 return NULL;
33761 }
33762
33763
33764 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33765 PyObject *resultobj = 0;
33766 wxWindow *arg1 = (wxWindow *) 0 ;
33767 wxWindow *arg2 = (wxWindow *) 0 ;
33768 void *argp1 = 0 ;
33769 int res1 = 0 ;
33770 void *argp2 = 0 ;
33771 int res2 = 0 ;
33772 PyObject * obj0 = 0 ;
33773 PyObject * obj1 = 0 ;
33774 char * kwnames[] = {
33775 (char *) "self",(char *) "child", NULL
33776 };
33777
33778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33780 if (!SWIG_IsOK(res1)) {
33781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33782 }
33783 arg1 = reinterpret_cast< wxWindow * >(argp1);
33784 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33785 if (!SWIG_IsOK(res2)) {
33786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33787 }
33788 arg2 = reinterpret_cast< wxWindow * >(argp2);
33789 {
33790 PyThreadState* __tstate = wxPyBeginAllowThreads();
33791 (arg1)->AddChild(arg2);
33792 wxPyEndAllowThreads(__tstate);
33793 if (PyErr_Occurred()) SWIG_fail;
33794 }
33795 resultobj = SWIG_Py_Void();
33796 return resultobj;
33797 fail:
33798 return NULL;
33799 }
33800
33801
33802 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33803 PyObject *resultobj = 0;
33804 wxWindow *arg1 = (wxWindow *) 0 ;
33805 wxWindow *arg2 = (wxWindow *) 0 ;
33806 void *argp1 = 0 ;
33807 int res1 = 0 ;
33808 void *argp2 = 0 ;
33809 int res2 = 0 ;
33810 PyObject * obj0 = 0 ;
33811 PyObject * obj1 = 0 ;
33812 char * kwnames[] = {
33813 (char *) "self",(char *) "child", NULL
33814 };
33815
33816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33818 if (!SWIG_IsOK(res1)) {
33819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33820 }
33821 arg1 = reinterpret_cast< wxWindow * >(argp1);
33822 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33823 if (!SWIG_IsOK(res2)) {
33824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33825 }
33826 arg2 = reinterpret_cast< wxWindow * >(argp2);
33827 {
33828 PyThreadState* __tstate = wxPyBeginAllowThreads();
33829 (arg1)->RemoveChild(arg2);
33830 wxPyEndAllowThreads(__tstate);
33831 if (PyErr_Occurred()) SWIG_fail;
33832 }
33833 resultobj = SWIG_Py_Void();
33834 return resultobj;
33835 fail:
33836 return NULL;
33837 }
33838
33839
33840 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33841 PyObject *resultobj = 0;
33842 wxWindow *arg1 = (wxWindow *) 0 ;
33843 bool arg2 ;
33844 void *argp1 = 0 ;
33845 int res1 = 0 ;
33846 bool val2 ;
33847 int ecode2 = 0 ;
33848 PyObject * obj0 = 0 ;
33849 PyObject * obj1 = 0 ;
33850 char * kwnames[] = {
33851 (char *) "self",(char *) "on", NULL
33852 };
33853
33854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33856 if (!SWIG_IsOK(res1)) {
33857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33858 }
33859 arg1 = reinterpret_cast< wxWindow * >(argp1);
33860 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33861 if (!SWIG_IsOK(ecode2)) {
33862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33863 }
33864 arg2 = static_cast< bool >(val2);
33865 {
33866 PyThreadState* __tstate = wxPyBeginAllowThreads();
33867 (arg1)->SetDoubleBuffered(arg2);
33868 wxPyEndAllowThreads(__tstate);
33869 if (PyErr_Occurred()) SWIG_fail;
33870 }
33871 resultobj = SWIG_Py_Void();
33872 return resultobj;
33873 fail:
33874 return NULL;
33875 }
33876
33877
33878 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33879 PyObject *resultobj = 0;
33880 wxWindow *arg1 = (wxWindow *) 0 ;
33881 long arg2 ;
33882 wxWindow *result = 0 ;
33883 void *argp1 = 0 ;
33884 int res1 = 0 ;
33885 long val2 ;
33886 int ecode2 = 0 ;
33887 PyObject * obj0 = 0 ;
33888 PyObject * obj1 = 0 ;
33889 char * kwnames[] = {
33890 (char *) "self",(char *) "winid", NULL
33891 };
33892
33893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33895 if (!SWIG_IsOK(res1)) {
33896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33897 }
33898 arg1 = reinterpret_cast< wxWindow * >(argp1);
33899 ecode2 = SWIG_AsVal_long(obj1, &val2);
33900 if (!SWIG_IsOK(ecode2)) {
33901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33902 }
33903 arg2 = static_cast< long >(val2);
33904 {
33905 PyThreadState* __tstate = wxPyBeginAllowThreads();
33906 result = (wxWindow *)(arg1)->FindWindow(arg2);
33907 wxPyEndAllowThreads(__tstate);
33908 if (PyErr_Occurred()) SWIG_fail;
33909 }
33910 {
33911 resultobj = wxPyMake_wxObject(result, 0);
33912 }
33913 return resultobj;
33914 fail:
33915 return NULL;
33916 }
33917
33918
33919 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33920 PyObject *resultobj = 0;
33921 wxWindow *arg1 = (wxWindow *) 0 ;
33922 wxString *arg2 = 0 ;
33923 wxWindow *result = 0 ;
33924 void *argp1 = 0 ;
33925 int res1 = 0 ;
33926 bool temp2 = false ;
33927 PyObject * obj0 = 0 ;
33928 PyObject * obj1 = 0 ;
33929 char * kwnames[] = {
33930 (char *) "self",(char *) "name", NULL
33931 };
33932
33933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33935 if (!SWIG_IsOK(res1)) {
33936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33937 }
33938 arg1 = reinterpret_cast< wxWindow * >(argp1);
33939 {
33940 arg2 = wxString_in_helper(obj1);
33941 if (arg2 == NULL) SWIG_fail;
33942 temp2 = true;
33943 }
33944 {
33945 PyThreadState* __tstate = wxPyBeginAllowThreads();
33946 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33947 wxPyEndAllowThreads(__tstate);
33948 if (PyErr_Occurred()) SWIG_fail;
33949 }
33950 {
33951 resultobj = wxPyMake_wxObject(result, 0);
33952 }
33953 {
33954 if (temp2)
33955 delete arg2;
33956 }
33957 return resultobj;
33958 fail:
33959 {
33960 if (temp2)
33961 delete arg2;
33962 }
33963 return NULL;
33964 }
33965
33966
33967 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33968 PyObject *resultobj = 0;
33969 wxWindow *arg1 = (wxWindow *) 0 ;
33970 wxEvtHandler *result = 0 ;
33971 void *argp1 = 0 ;
33972 int res1 = 0 ;
33973 PyObject *swig_obj[1] ;
33974
33975 if (!args) SWIG_fail;
33976 swig_obj[0] = args;
33977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33978 if (!SWIG_IsOK(res1)) {
33979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33980 }
33981 arg1 = reinterpret_cast< wxWindow * >(argp1);
33982 {
33983 PyThreadState* __tstate = wxPyBeginAllowThreads();
33984 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33985 wxPyEndAllowThreads(__tstate);
33986 if (PyErr_Occurred()) SWIG_fail;
33987 }
33988 {
33989 resultobj = wxPyMake_wxObject(result, 0);
33990 }
33991 return resultobj;
33992 fail:
33993 return NULL;
33994 }
33995
33996
33997 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33998 PyObject *resultobj = 0;
33999 wxWindow *arg1 = (wxWindow *) 0 ;
34000 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34001 void *argp1 = 0 ;
34002 int res1 = 0 ;
34003 void *argp2 = 0 ;
34004 int res2 = 0 ;
34005 PyObject * obj0 = 0 ;
34006 PyObject * obj1 = 0 ;
34007 char * kwnames[] = {
34008 (char *) "self",(char *) "handler", NULL
34009 };
34010
34011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34013 if (!SWIG_IsOK(res1)) {
34014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34015 }
34016 arg1 = reinterpret_cast< wxWindow * >(argp1);
34017 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34018 if (!SWIG_IsOK(res2)) {
34019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34020 }
34021 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34022 {
34023 PyThreadState* __tstate = wxPyBeginAllowThreads();
34024 (arg1)->SetEventHandler(arg2);
34025 wxPyEndAllowThreads(__tstate);
34026 if (PyErr_Occurred()) SWIG_fail;
34027 }
34028 resultobj = SWIG_Py_Void();
34029 return resultobj;
34030 fail:
34031 return NULL;
34032 }
34033
34034
34035 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34036 PyObject *resultobj = 0;
34037 wxWindow *arg1 = (wxWindow *) 0 ;
34038 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34039 void *argp1 = 0 ;
34040 int res1 = 0 ;
34041 void *argp2 = 0 ;
34042 int res2 = 0 ;
34043 PyObject * obj0 = 0 ;
34044 PyObject * obj1 = 0 ;
34045 char * kwnames[] = {
34046 (char *) "self",(char *) "handler", NULL
34047 };
34048
34049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34051 if (!SWIG_IsOK(res1)) {
34052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34053 }
34054 arg1 = reinterpret_cast< wxWindow * >(argp1);
34055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34056 if (!SWIG_IsOK(res2)) {
34057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34058 }
34059 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34060 {
34061 PyThreadState* __tstate = wxPyBeginAllowThreads();
34062 (arg1)->PushEventHandler(arg2);
34063 wxPyEndAllowThreads(__tstate);
34064 if (PyErr_Occurred()) SWIG_fail;
34065 }
34066 resultobj = SWIG_Py_Void();
34067 return resultobj;
34068 fail:
34069 return NULL;
34070 }
34071
34072
34073 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34074 PyObject *resultobj = 0;
34075 wxWindow *arg1 = (wxWindow *) 0 ;
34076 bool arg2 = (bool) false ;
34077 wxEvtHandler *result = 0 ;
34078 void *argp1 = 0 ;
34079 int res1 = 0 ;
34080 bool val2 ;
34081 int ecode2 = 0 ;
34082 PyObject * obj0 = 0 ;
34083 PyObject * obj1 = 0 ;
34084 char * kwnames[] = {
34085 (char *) "self",(char *) "deleteHandler", NULL
34086 };
34087
34088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34090 if (!SWIG_IsOK(res1)) {
34091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34092 }
34093 arg1 = reinterpret_cast< wxWindow * >(argp1);
34094 if (obj1) {
34095 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34096 if (!SWIG_IsOK(ecode2)) {
34097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
34098 }
34099 arg2 = static_cast< bool >(val2);
34100 }
34101 {
34102 PyThreadState* __tstate = wxPyBeginAllowThreads();
34103 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
34104 wxPyEndAllowThreads(__tstate);
34105 if (PyErr_Occurred()) SWIG_fail;
34106 }
34107 {
34108 resultobj = wxPyMake_wxObject(result, 0);
34109 }
34110 return resultobj;
34111 fail:
34112 return NULL;
34113 }
34114
34115
34116 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34117 PyObject *resultobj = 0;
34118 wxWindow *arg1 = (wxWindow *) 0 ;
34119 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34120 bool result;
34121 void *argp1 = 0 ;
34122 int res1 = 0 ;
34123 void *argp2 = 0 ;
34124 int res2 = 0 ;
34125 PyObject * obj0 = 0 ;
34126 PyObject * obj1 = 0 ;
34127 char * kwnames[] = {
34128 (char *) "self",(char *) "handler", NULL
34129 };
34130
34131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
34132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34133 if (!SWIG_IsOK(res1)) {
34134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
34135 }
34136 arg1 = reinterpret_cast< wxWindow * >(argp1);
34137 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
34138 if (!SWIG_IsOK(res2)) {
34139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
34140 }
34141 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
34142 {
34143 PyThreadState* __tstate = wxPyBeginAllowThreads();
34144 result = (bool)(arg1)->RemoveEventHandler(arg2);
34145 wxPyEndAllowThreads(__tstate);
34146 if (PyErr_Occurred()) SWIG_fail;
34147 }
34148 {
34149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34150 }
34151 return resultobj;
34152 fail:
34153 return NULL;
34154 }
34155
34156
34157 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34158 PyObject *resultobj = 0;
34159 wxWindow *arg1 = (wxWindow *) 0 ;
34160 wxValidator *arg2 = 0 ;
34161 void *argp1 = 0 ;
34162 int res1 = 0 ;
34163 void *argp2 = 0 ;
34164 int res2 = 0 ;
34165 PyObject * obj0 = 0 ;
34166 PyObject * obj1 = 0 ;
34167 char * kwnames[] = {
34168 (char *) "self",(char *) "validator", NULL
34169 };
34170
34171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
34172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34173 if (!SWIG_IsOK(res1)) {
34174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34175 }
34176 arg1 = reinterpret_cast< wxWindow * >(argp1);
34177 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
34178 if (!SWIG_IsOK(res2)) {
34179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34180 }
34181 if (!argp2) {
34182 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
34183 }
34184 arg2 = reinterpret_cast< wxValidator * >(argp2);
34185 {
34186 PyThreadState* __tstate = wxPyBeginAllowThreads();
34187 (arg1)->SetValidator((wxValidator const &)*arg2);
34188 wxPyEndAllowThreads(__tstate);
34189 if (PyErr_Occurred()) SWIG_fail;
34190 }
34191 resultobj = SWIG_Py_Void();
34192 return resultobj;
34193 fail:
34194 return NULL;
34195 }
34196
34197
34198 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34199 PyObject *resultobj = 0;
34200 wxWindow *arg1 = (wxWindow *) 0 ;
34201 wxValidator *result = 0 ;
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_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
34211 }
34212 arg1 = reinterpret_cast< wxWindow * >(argp1);
34213 {
34214 PyThreadState* __tstate = wxPyBeginAllowThreads();
34215 result = (wxValidator *)(arg1)->GetValidator();
34216 wxPyEndAllowThreads(__tstate);
34217 if (PyErr_Occurred()) SWIG_fail;
34218 }
34219 {
34220 resultobj = wxPyMake_wxObject(result, (bool)0);
34221 }
34222 return resultobj;
34223 fail:
34224 return NULL;
34225 }
34226
34227
34228 SWIGINTERN PyObject *_wrap_Window_Validate(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_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
34241 }
34242 arg1 = reinterpret_cast< wxWindow * >(argp1);
34243 {
34244 PyThreadState* __tstate = wxPyBeginAllowThreads();
34245 result = (bool)(arg1)->Validate();
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_TransferDataToWindow(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_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34271 }
34272 arg1 = reinterpret_cast< wxWindow * >(argp1);
34273 {
34274 PyThreadState* __tstate = wxPyBeginAllowThreads();
34275 result = (bool)(arg1)->TransferDataToWindow();
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_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34289 PyObject *resultobj = 0;
34290 wxWindow *arg1 = (wxWindow *) 0 ;
34291 bool result;
34292 void *argp1 = 0 ;
34293 int res1 = 0 ;
34294 PyObject *swig_obj[1] ;
34295
34296 if (!args) SWIG_fail;
34297 swig_obj[0] = args;
34298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34299 if (!SWIG_IsOK(res1)) {
34300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
34301 }
34302 arg1 = reinterpret_cast< wxWindow * >(argp1);
34303 {
34304 PyThreadState* __tstate = wxPyBeginAllowThreads();
34305 result = (bool)(arg1)->TransferDataFromWindow();
34306 wxPyEndAllowThreads(__tstate);
34307 if (PyErr_Occurred()) SWIG_fail;
34308 }
34309 {
34310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34311 }
34312 return resultobj;
34313 fail:
34314 return NULL;
34315 }
34316
34317
34318 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34319 PyObject *resultobj = 0;
34320 wxWindow *arg1 = (wxWindow *) 0 ;
34321 void *argp1 = 0 ;
34322 int res1 = 0 ;
34323 PyObject *swig_obj[1] ;
34324
34325 if (!args) SWIG_fail;
34326 swig_obj[0] = args;
34327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34328 if (!SWIG_IsOK(res1)) {
34329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34330 }
34331 arg1 = reinterpret_cast< wxWindow * >(argp1);
34332 {
34333 PyThreadState* __tstate = wxPyBeginAllowThreads();
34334 (arg1)->InitDialog();
34335 wxPyEndAllowThreads(__tstate);
34336 if (PyErr_Occurred()) SWIG_fail;
34337 }
34338 resultobj = SWIG_Py_Void();
34339 return resultobj;
34340 fail:
34341 return NULL;
34342 }
34343
34344
34345 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34346 PyObject *resultobj = 0;
34347 wxWindow *arg1 = (wxWindow *) 0 ;
34348 wxAcceleratorTable *arg2 = 0 ;
34349 void *argp1 = 0 ;
34350 int res1 = 0 ;
34351 void *argp2 = 0 ;
34352 int res2 = 0 ;
34353 PyObject * obj0 = 0 ;
34354 PyObject * obj1 = 0 ;
34355 char * kwnames[] = {
34356 (char *) "self",(char *) "accel", NULL
34357 };
34358
34359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
34360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34361 if (!SWIG_IsOK(res1)) {
34362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34363 }
34364 arg1 = reinterpret_cast< wxWindow * >(argp1);
34365 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
34366 if (!SWIG_IsOK(res2)) {
34367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34368 }
34369 if (!argp2) {
34370 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
34371 }
34372 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
34373 {
34374 PyThreadState* __tstate = wxPyBeginAllowThreads();
34375 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
34376 wxPyEndAllowThreads(__tstate);
34377 if (PyErr_Occurred()) SWIG_fail;
34378 }
34379 resultobj = SWIG_Py_Void();
34380 return resultobj;
34381 fail:
34382 return NULL;
34383 }
34384
34385
34386 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34387 PyObject *resultobj = 0;
34388 wxWindow *arg1 = (wxWindow *) 0 ;
34389 wxAcceleratorTable *result = 0 ;
34390 void *argp1 = 0 ;
34391 int res1 = 0 ;
34392 PyObject *swig_obj[1] ;
34393
34394 if (!args) SWIG_fail;
34395 swig_obj[0] = args;
34396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34397 if (!SWIG_IsOK(res1)) {
34398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
34399 }
34400 arg1 = reinterpret_cast< wxWindow * >(argp1);
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
34404 wxPyEndAllowThreads(__tstate);
34405 if (PyErr_Occurred()) SWIG_fail;
34406 }
34407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
34408 return resultobj;
34409 fail:
34410 return NULL;
34411 }
34412
34413
34414 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34415 PyObject *resultobj = 0;
34416 wxWindow *arg1 = (wxWindow *) 0 ;
34417 int arg2 ;
34418 int arg3 ;
34419 int arg4 ;
34420 bool result;
34421 void *argp1 = 0 ;
34422 int res1 = 0 ;
34423 int val2 ;
34424 int ecode2 = 0 ;
34425 int val3 ;
34426 int ecode3 = 0 ;
34427 int val4 ;
34428 int ecode4 = 0 ;
34429 PyObject * obj0 = 0 ;
34430 PyObject * obj1 = 0 ;
34431 PyObject * obj2 = 0 ;
34432 PyObject * obj3 = 0 ;
34433 char * kwnames[] = {
34434 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
34435 };
34436
34437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34439 if (!SWIG_IsOK(res1)) {
34440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34441 }
34442 arg1 = reinterpret_cast< wxWindow * >(argp1);
34443 ecode2 = SWIG_AsVal_int(obj1, &val2);
34444 if (!SWIG_IsOK(ecode2)) {
34445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
34446 }
34447 arg2 = static_cast< int >(val2);
34448 ecode3 = SWIG_AsVal_int(obj2, &val3);
34449 if (!SWIG_IsOK(ecode3)) {
34450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
34451 }
34452 arg3 = static_cast< int >(val3);
34453 ecode4 = SWIG_AsVal_int(obj3, &val4);
34454 if (!SWIG_IsOK(ecode4)) {
34455 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
34456 }
34457 arg4 = static_cast< int >(val4);
34458 {
34459 PyThreadState* __tstate = wxPyBeginAllowThreads();
34460 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
34461 wxPyEndAllowThreads(__tstate);
34462 if (PyErr_Occurred()) SWIG_fail;
34463 }
34464 {
34465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34466 }
34467 return resultobj;
34468 fail:
34469 return NULL;
34470 }
34471
34472
34473 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34474 PyObject *resultobj = 0;
34475 wxWindow *arg1 = (wxWindow *) 0 ;
34476 int arg2 ;
34477 bool result;
34478 void *argp1 = 0 ;
34479 int res1 = 0 ;
34480 int val2 ;
34481 int ecode2 = 0 ;
34482 PyObject * obj0 = 0 ;
34483 PyObject * obj1 = 0 ;
34484 char * kwnames[] = {
34485 (char *) "self",(char *) "hotkeyId", NULL
34486 };
34487
34488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
34489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34490 if (!SWIG_IsOK(res1)) {
34491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
34492 }
34493 arg1 = reinterpret_cast< wxWindow * >(argp1);
34494 ecode2 = SWIG_AsVal_int(obj1, &val2);
34495 if (!SWIG_IsOK(ecode2)) {
34496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
34497 }
34498 arg2 = static_cast< int >(val2);
34499 {
34500 PyThreadState* __tstate = wxPyBeginAllowThreads();
34501 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
34502 wxPyEndAllowThreads(__tstate);
34503 if (PyErr_Occurred()) SWIG_fail;
34504 }
34505 {
34506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34507 }
34508 return resultobj;
34509 fail:
34510 return NULL;
34511 }
34512
34513
34514 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34515 PyObject *resultobj = 0;
34516 wxWindow *arg1 = (wxWindow *) 0 ;
34517 wxPoint *arg2 = 0 ;
34518 wxPoint result;
34519 void *argp1 = 0 ;
34520 int res1 = 0 ;
34521 wxPoint temp2 ;
34522 PyObject * obj0 = 0 ;
34523 PyObject * obj1 = 0 ;
34524 char * kwnames[] = {
34525 (char *) "self",(char *) "pt", NULL
34526 };
34527
34528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34530 if (!SWIG_IsOK(res1)) {
34531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34532 }
34533 arg1 = reinterpret_cast< wxWindow * >(argp1);
34534 {
34535 arg2 = &temp2;
34536 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34537 }
34538 {
34539 PyThreadState* __tstate = wxPyBeginAllowThreads();
34540 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34541 wxPyEndAllowThreads(__tstate);
34542 if (PyErr_Occurred()) SWIG_fail;
34543 }
34544 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34545 return resultobj;
34546 fail:
34547 return NULL;
34548 }
34549
34550
34551 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34552 PyObject *resultobj = 0;
34553 wxWindow *arg1 = (wxWindow *) 0 ;
34554 wxSize *arg2 = 0 ;
34555 wxSize result;
34556 void *argp1 = 0 ;
34557 int res1 = 0 ;
34558 wxSize temp2 ;
34559 PyObject * obj0 = 0 ;
34560 PyObject * obj1 = 0 ;
34561 char * kwnames[] = {
34562 (char *) "self",(char *) "sz", NULL
34563 };
34564
34565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34567 if (!SWIG_IsOK(res1)) {
34568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34569 }
34570 arg1 = reinterpret_cast< wxWindow * >(argp1);
34571 {
34572 arg2 = &temp2;
34573 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34574 }
34575 {
34576 PyThreadState* __tstate = wxPyBeginAllowThreads();
34577 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34578 wxPyEndAllowThreads(__tstate);
34579 if (PyErr_Occurred()) SWIG_fail;
34580 }
34581 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34582 return resultobj;
34583 fail:
34584 return NULL;
34585 }
34586
34587
34588 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34589 PyObject *resultobj = 0;
34590 wxWindow *arg1 = (wxWindow *) 0 ;
34591 wxPoint *arg2 = 0 ;
34592 wxPoint result;
34593 void *argp1 = 0 ;
34594 int res1 = 0 ;
34595 wxPoint temp2 ;
34596 PyObject * obj0 = 0 ;
34597 PyObject * obj1 = 0 ;
34598 char * kwnames[] = {
34599 (char *) "self",(char *) "pt", NULL
34600 };
34601
34602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34604 if (!SWIG_IsOK(res1)) {
34605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34606 }
34607 arg1 = reinterpret_cast< wxWindow * >(argp1);
34608 {
34609 arg2 = &temp2;
34610 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34611 }
34612 {
34613 PyThreadState* __tstate = wxPyBeginAllowThreads();
34614 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34615 wxPyEndAllowThreads(__tstate);
34616 if (PyErr_Occurred()) SWIG_fail;
34617 }
34618 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34619 return resultobj;
34620 fail:
34621 return NULL;
34622 }
34623
34624
34625 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34626 PyObject *resultobj = 0;
34627 wxWindow *arg1 = (wxWindow *) 0 ;
34628 wxSize *arg2 = 0 ;
34629 wxSize result;
34630 void *argp1 = 0 ;
34631 int res1 = 0 ;
34632 wxSize temp2 ;
34633 PyObject * obj0 = 0 ;
34634 PyObject * obj1 = 0 ;
34635 char * kwnames[] = {
34636 (char *) "self",(char *) "sz", NULL
34637 };
34638
34639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34641 if (!SWIG_IsOK(res1)) {
34642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34643 }
34644 arg1 = reinterpret_cast< wxWindow * >(argp1);
34645 {
34646 arg2 = &temp2;
34647 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34648 }
34649 {
34650 PyThreadState* __tstate = wxPyBeginAllowThreads();
34651 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34652 wxPyEndAllowThreads(__tstate);
34653 if (PyErr_Occurred()) SWIG_fail;
34654 }
34655 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34656 return resultobj;
34657 fail:
34658 return NULL;
34659 }
34660
34661
34662 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34663 PyObject *resultobj = 0;
34664 wxWindow *arg1 = (wxWindow *) 0 ;
34665 wxPoint *arg2 = 0 ;
34666 wxPoint result;
34667 void *argp1 = 0 ;
34668 int res1 = 0 ;
34669 wxPoint temp2 ;
34670 PyObject * obj0 = 0 ;
34671 PyObject * obj1 = 0 ;
34672 char * kwnames[] = {
34673 (char *) "self",(char *) "pt", NULL
34674 };
34675
34676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34678 if (!SWIG_IsOK(res1)) {
34679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34680 }
34681 arg1 = reinterpret_cast< wxWindow * >(argp1);
34682 {
34683 arg2 = &temp2;
34684 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34685 }
34686 {
34687 PyThreadState* __tstate = wxPyBeginAllowThreads();
34688 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34689 wxPyEndAllowThreads(__tstate);
34690 if (PyErr_Occurred()) SWIG_fail;
34691 }
34692 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34693 return resultobj;
34694 fail:
34695 return NULL;
34696 }
34697
34698
34699 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34700 PyObject *resultobj = 0;
34701 wxWindow *arg1 = (wxWindow *) 0 ;
34702 wxSize *arg2 = 0 ;
34703 wxSize result;
34704 void *argp1 = 0 ;
34705 int res1 = 0 ;
34706 wxSize temp2 ;
34707 PyObject * obj0 = 0 ;
34708 PyObject * obj1 = 0 ;
34709 char * kwnames[] = {
34710 (char *) "self",(char *) "sz", NULL
34711 };
34712
34713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34715 if (!SWIG_IsOK(res1)) {
34716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34717 }
34718 arg1 = reinterpret_cast< wxWindow * >(argp1);
34719 {
34720 arg2 = &temp2;
34721 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34722 }
34723 {
34724 PyThreadState* __tstate = wxPyBeginAllowThreads();
34725 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34726 wxPyEndAllowThreads(__tstate);
34727 if (PyErr_Occurred()) SWIG_fail;
34728 }
34729 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34730 return resultobj;
34731 fail:
34732 return NULL;
34733 }
34734
34735
34736 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34737 PyObject *resultobj = 0;
34738 wxWindow *arg1 = (wxWindow *) 0 ;
34739 int arg2 ;
34740 int arg3 ;
34741 void *argp1 = 0 ;
34742 int res1 = 0 ;
34743 int val2 ;
34744 int ecode2 = 0 ;
34745 int val3 ;
34746 int ecode3 = 0 ;
34747 PyObject * obj0 = 0 ;
34748 PyObject * obj1 = 0 ;
34749 PyObject * obj2 = 0 ;
34750 char * kwnames[] = {
34751 (char *) "self",(char *) "x",(char *) "y", NULL
34752 };
34753
34754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34756 if (!SWIG_IsOK(res1)) {
34757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34758 }
34759 arg1 = reinterpret_cast< wxWindow * >(argp1);
34760 ecode2 = SWIG_AsVal_int(obj1, &val2);
34761 if (!SWIG_IsOK(ecode2)) {
34762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34763 }
34764 arg2 = static_cast< int >(val2);
34765 ecode3 = SWIG_AsVal_int(obj2, &val3);
34766 if (!SWIG_IsOK(ecode3)) {
34767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34768 }
34769 arg3 = static_cast< int >(val3);
34770 {
34771 PyThreadState* __tstate = wxPyBeginAllowThreads();
34772 (arg1)->WarpPointer(arg2,arg3);
34773 wxPyEndAllowThreads(__tstate);
34774 if (PyErr_Occurred()) SWIG_fail;
34775 }
34776 resultobj = SWIG_Py_Void();
34777 return resultobj;
34778 fail:
34779 return NULL;
34780 }
34781
34782
34783 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34784 PyObject *resultobj = 0;
34785 wxWindow *arg1 = (wxWindow *) 0 ;
34786 void *argp1 = 0 ;
34787 int res1 = 0 ;
34788 PyObject *swig_obj[1] ;
34789
34790 if (!args) SWIG_fail;
34791 swig_obj[0] = args;
34792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34793 if (!SWIG_IsOK(res1)) {
34794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34795 }
34796 arg1 = reinterpret_cast< wxWindow * >(argp1);
34797 {
34798 PyThreadState* __tstate = wxPyBeginAllowThreads();
34799 (arg1)->CaptureMouse();
34800 wxPyEndAllowThreads(__tstate);
34801 if (PyErr_Occurred()) SWIG_fail;
34802 }
34803 resultobj = SWIG_Py_Void();
34804 return resultobj;
34805 fail:
34806 return NULL;
34807 }
34808
34809
34810 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34811 PyObject *resultobj = 0;
34812 wxWindow *arg1 = (wxWindow *) 0 ;
34813 void *argp1 = 0 ;
34814 int res1 = 0 ;
34815 PyObject *swig_obj[1] ;
34816
34817 if (!args) SWIG_fail;
34818 swig_obj[0] = args;
34819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34820 if (!SWIG_IsOK(res1)) {
34821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34822 }
34823 arg1 = reinterpret_cast< wxWindow * >(argp1);
34824 {
34825 PyThreadState* __tstate = wxPyBeginAllowThreads();
34826 (arg1)->ReleaseMouse();
34827 wxPyEndAllowThreads(__tstate);
34828 if (PyErr_Occurred()) SWIG_fail;
34829 }
34830 resultobj = SWIG_Py_Void();
34831 return resultobj;
34832 fail:
34833 return NULL;
34834 }
34835
34836
34837 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34838 PyObject *resultobj = 0;
34839 wxWindow *result = 0 ;
34840
34841 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34842 {
34843 if (!wxPyCheckForApp()) SWIG_fail;
34844 PyThreadState* __tstate = wxPyBeginAllowThreads();
34845 result = (wxWindow *)wxWindow::GetCapture();
34846 wxPyEndAllowThreads(__tstate);
34847 if (PyErr_Occurred()) SWIG_fail;
34848 }
34849 {
34850 resultobj = wxPyMake_wxObject(result, 0);
34851 }
34852 return resultobj;
34853 fail:
34854 return NULL;
34855 }
34856
34857
34858 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34859 PyObject *resultobj = 0;
34860 wxWindow *arg1 = (wxWindow *) 0 ;
34861 bool result;
34862 void *argp1 = 0 ;
34863 int res1 = 0 ;
34864 PyObject *swig_obj[1] ;
34865
34866 if (!args) SWIG_fail;
34867 swig_obj[0] = args;
34868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34869 if (!SWIG_IsOK(res1)) {
34870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34871 }
34872 arg1 = reinterpret_cast< wxWindow * >(argp1);
34873 {
34874 PyThreadState* __tstate = wxPyBeginAllowThreads();
34875 result = (bool)((wxWindow const *)arg1)->HasCapture();
34876 wxPyEndAllowThreads(__tstate);
34877 if (PyErr_Occurred()) SWIG_fail;
34878 }
34879 {
34880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34881 }
34882 return resultobj;
34883 fail:
34884 return NULL;
34885 }
34886
34887
34888 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34889 PyObject *resultobj = 0;
34890 wxWindow *arg1 = (wxWindow *) 0 ;
34891 bool arg2 = (bool) true ;
34892 wxRect *arg3 = (wxRect *) NULL ;
34893 void *argp1 = 0 ;
34894 int res1 = 0 ;
34895 bool val2 ;
34896 int ecode2 = 0 ;
34897 void *argp3 = 0 ;
34898 int res3 = 0 ;
34899 PyObject * obj0 = 0 ;
34900 PyObject * obj1 = 0 ;
34901 PyObject * obj2 = 0 ;
34902 char * kwnames[] = {
34903 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34904 };
34905
34906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34908 if (!SWIG_IsOK(res1)) {
34909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34910 }
34911 arg1 = reinterpret_cast< wxWindow * >(argp1);
34912 if (obj1) {
34913 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34914 if (!SWIG_IsOK(ecode2)) {
34915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34916 }
34917 arg2 = static_cast< bool >(val2);
34918 }
34919 if (obj2) {
34920 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34921 if (!SWIG_IsOK(res3)) {
34922 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34923 }
34924 arg3 = reinterpret_cast< wxRect * >(argp3);
34925 }
34926 {
34927 PyThreadState* __tstate = wxPyBeginAllowThreads();
34928 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34929 wxPyEndAllowThreads(__tstate);
34930 if (PyErr_Occurred()) SWIG_fail;
34931 }
34932 resultobj = SWIG_Py_Void();
34933 return resultobj;
34934 fail:
34935 return NULL;
34936 }
34937
34938
34939 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34940 PyObject *resultobj = 0;
34941 wxWindow *arg1 = (wxWindow *) 0 ;
34942 wxRect *arg2 = 0 ;
34943 bool arg3 = (bool) true ;
34944 void *argp1 = 0 ;
34945 int res1 = 0 ;
34946 wxRect temp2 ;
34947 bool val3 ;
34948 int ecode3 = 0 ;
34949 PyObject * obj0 = 0 ;
34950 PyObject * obj1 = 0 ;
34951 PyObject * obj2 = 0 ;
34952 char * kwnames[] = {
34953 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34954 };
34955
34956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34958 if (!SWIG_IsOK(res1)) {
34959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34960 }
34961 arg1 = reinterpret_cast< wxWindow * >(argp1);
34962 {
34963 arg2 = &temp2;
34964 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34965 }
34966 if (obj2) {
34967 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34968 if (!SWIG_IsOK(ecode3)) {
34969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34970 }
34971 arg3 = static_cast< bool >(val3);
34972 }
34973 {
34974 PyThreadState* __tstate = wxPyBeginAllowThreads();
34975 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34976 wxPyEndAllowThreads(__tstate);
34977 if (PyErr_Occurred()) SWIG_fail;
34978 }
34979 resultobj = SWIG_Py_Void();
34980 return resultobj;
34981 fail:
34982 return NULL;
34983 }
34984
34985
34986 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34987 PyObject *resultobj = 0;
34988 wxWindow *arg1 = (wxWindow *) 0 ;
34989 void *argp1 = 0 ;
34990 int res1 = 0 ;
34991 PyObject *swig_obj[1] ;
34992
34993 if (!args) SWIG_fail;
34994 swig_obj[0] = args;
34995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34996 if (!SWIG_IsOK(res1)) {
34997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34998 }
34999 arg1 = reinterpret_cast< wxWindow * >(argp1);
35000 {
35001 PyThreadState* __tstate = wxPyBeginAllowThreads();
35002 (arg1)->Update();
35003 wxPyEndAllowThreads(__tstate);
35004 if (PyErr_Occurred()) SWIG_fail;
35005 }
35006 resultobj = SWIG_Py_Void();
35007 return resultobj;
35008 fail:
35009 return NULL;
35010 }
35011
35012
35013 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35014 PyObject *resultobj = 0;
35015 wxWindow *arg1 = (wxWindow *) 0 ;
35016 void *argp1 = 0 ;
35017 int res1 = 0 ;
35018 PyObject *swig_obj[1] ;
35019
35020 if (!args) SWIG_fail;
35021 swig_obj[0] = args;
35022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35023 if (!SWIG_IsOK(res1)) {
35024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35025 }
35026 arg1 = reinterpret_cast< wxWindow * >(argp1);
35027 {
35028 PyThreadState* __tstate = wxPyBeginAllowThreads();
35029 (arg1)->ClearBackground();
35030 wxPyEndAllowThreads(__tstate);
35031 if (PyErr_Occurred()) SWIG_fail;
35032 }
35033 resultobj = SWIG_Py_Void();
35034 return resultobj;
35035 fail:
35036 return NULL;
35037 }
35038
35039
35040 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35041 PyObject *resultobj = 0;
35042 wxWindow *arg1 = (wxWindow *) 0 ;
35043 void *argp1 = 0 ;
35044 int res1 = 0 ;
35045 PyObject *swig_obj[1] ;
35046
35047 if (!args) SWIG_fail;
35048 swig_obj[0] = args;
35049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35050 if (!SWIG_IsOK(res1)) {
35051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
35052 }
35053 arg1 = reinterpret_cast< wxWindow * >(argp1);
35054 {
35055 PyThreadState* __tstate = wxPyBeginAllowThreads();
35056 (arg1)->Freeze();
35057 wxPyEndAllowThreads(__tstate);
35058 if (PyErr_Occurred()) SWIG_fail;
35059 }
35060 resultobj = SWIG_Py_Void();
35061 return resultobj;
35062 fail:
35063 return NULL;
35064 }
35065
35066
35067 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35068 PyObject *resultobj = 0;
35069 wxWindow *arg1 = (wxWindow *) 0 ;
35070 bool result;
35071 void *argp1 = 0 ;
35072 int res1 = 0 ;
35073 PyObject *swig_obj[1] ;
35074
35075 if (!args) SWIG_fail;
35076 swig_obj[0] = args;
35077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35078 if (!SWIG_IsOK(res1)) {
35079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35080 }
35081 arg1 = reinterpret_cast< wxWindow * >(argp1);
35082 {
35083 PyThreadState* __tstate = wxPyBeginAllowThreads();
35084 result = (bool)((wxWindow const *)arg1)->IsFrozen();
35085 wxPyEndAllowThreads(__tstate);
35086 if (PyErr_Occurred()) SWIG_fail;
35087 }
35088 {
35089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35090 }
35091 return resultobj;
35092 fail:
35093 return NULL;
35094 }
35095
35096
35097 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35098 PyObject *resultobj = 0;
35099 wxWindow *arg1 = (wxWindow *) 0 ;
35100 void *argp1 = 0 ;
35101 int res1 = 0 ;
35102 PyObject *swig_obj[1] ;
35103
35104 if (!args) SWIG_fail;
35105 swig_obj[0] = args;
35106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35107 if (!SWIG_IsOK(res1)) {
35108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
35109 }
35110 arg1 = reinterpret_cast< wxWindow * >(argp1);
35111 {
35112 PyThreadState* __tstate = wxPyBeginAllowThreads();
35113 (arg1)->Thaw();
35114 wxPyEndAllowThreads(__tstate);
35115 if (PyErr_Occurred()) SWIG_fail;
35116 }
35117 resultobj = SWIG_Py_Void();
35118 return resultobj;
35119 fail:
35120 return NULL;
35121 }
35122
35123
35124 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35125 PyObject *resultobj = 0;
35126 wxWindow *arg1 = (wxWindow *) 0 ;
35127 wxDC *arg2 = 0 ;
35128 void *argp1 = 0 ;
35129 int res1 = 0 ;
35130 void *argp2 = 0 ;
35131 int res2 = 0 ;
35132 PyObject * obj0 = 0 ;
35133 PyObject * obj1 = 0 ;
35134 char * kwnames[] = {
35135 (char *) "self",(char *) "dc", NULL
35136 };
35137
35138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
35139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35140 if (!SWIG_IsOK(res1)) {
35141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
35142 }
35143 arg1 = reinterpret_cast< wxWindow * >(argp1);
35144 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
35145 if (!SWIG_IsOK(res2)) {
35146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35147 }
35148 if (!argp2) {
35149 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
35150 }
35151 arg2 = reinterpret_cast< wxDC * >(argp2);
35152 {
35153 PyThreadState* __tstate = wxPyBeginAllowThreads();
35154 (arg1)->PrepareDC(*arg2);
35155 wxPyEndAllowThreads(__tstate);
35156 if (PyErr_Occurred()) SWIG_fail;
35157 }
35158 resultobj = SWIG_Py_Void();
35159 return resultobj;
35160 fail:
35161 return NULL;
35162 }
35163
35164
35165 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35166 PyObject *resultobj = 0;
35167 wxWindow *arg1 = (wxWindow *) 0 ;
35168 wxRegion *result = 0 ;
35169 void *argp1 = 0 ;
35170 int res1 = 0 ;
35171 PyObject *swig_obj[1] ;
35172
35173 if (!args) SWIG_fail;
35174 swig_obj[0] = args;
35175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35176 if (!SWIG_IsOK(res1)) {
35177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
35178 }
35179 arg1 = reinterpret_cast< wxWindow * >(argp1);
35180 {
35181 PyThreadState* __tstate = wxPyBeginAllowThreads();
35182 {
35183 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
35184 result = (wxRegion *) &_result_ref;
35185 }
35186 wxPyEndAllowThreads(__tstate);
35187 if (PyErr_Occurred()) SWIG_fail;
35188 }
35189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
35190 return resultobj;
35191 fail:
35192 return NULL;
35193 }
35194
35195
35196 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35197 PyObject *resultobj = 0;
35198 wxWindow *arg1 = (wxWindow *) 0 ;
35199 wxRect result;
35200 void *argp1 = 0 ;
35201 int res1 = 0 ;
35202 PyObject *swig_obj[1] ;
35203
35204 if (!args) SWIG_fail;
35205 swig_obj[0] = args;
35206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35207 if (!SWIG_IsOK(res1)) {
35208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35209 }
35210 arg1 = reinterpret_cast< wxWindow * >(argp1);
35211 {
35212 PyThreadState* __tstate = wxPyBeginAllowThreads();
35213 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
35214 wxPyEndAllowThreads(__tstate);
35215 if (PyErr_Occurred()) SWIG_fail;
35216 }
35217 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35218 return resultobj;
35219 fail:
35220 return NULL;
35221 }
35222
35223
35224 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35225 PyObject *resultobj = 0;
35226 wxWindow *arg1 = (wxWindow *) 0 ;
35227 int arg2 ;
35228 int arg3 ;
35229 int arg4 = (int) 1 ;
35230 int arg5 = (int) 1 ;
35231 bool result;
35232 void *argp1 = 0 ;
35233 int res1 = 0 ;
35234 int val2 ;
35235 int ecode2 = 0 ;
35236 int val3 ;
35237 int ecode3 = 0 ;
35238 int val4 ;
35239 int ecode4 = 0 ;
35240 int val5 ;
35241 int ecode5 = 0 ;
35242 PyObject * obj0 = 0 ;
35243 PyObject * obj1 = 0 ;
35244 PyObject * obj2 = 0 ;
35245 PyObject * obj3 = 0 ;
35246 PyObject * obj4 = 0 ;
35247 char * kwnames[] = {
35248 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
35249 };
35250
35251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35253 if (!SWIG_IsOK(res1)) {
35254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
35255 }
35256 arg1 = reinterpret_cast< wxWindow * >(argp1);
35257 ecode2 = SWIG_AsVal_int(obj1, &val2);
35258 if (!SWIG_IsOK(ecode2)) {
35259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
35260 }
35261 arg2 = static_cast< int >(val2);
35262 ecode3 = SWIG_AsVal_int(obj2, &val3);
35263 if (!SWIG_IsOK(ecode3)) {
35264 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
35265 }
35266 arg3 = static_cast< int >(val3);
35267 if (obj3) {
35268 ecode4 = SWIG_AsVal_int(obj3, &val4);
35269 if (!SWIG_IsOK(ecode4)) {
35270 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
35271 }
35272 arg4 = static_cast< int >(val4);
35273 }
35274 if (obj4) {
35275 ecode5 = SWIG_AsVal_int(obj4, &val5);
35276 if (!SWIG_IsOK(ecode5)) {
35277 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
35278 }
35279 arg5 = static_cast< int >(val5);
35280 }
35281 {
35282 PyThreadState* __tstate = wxPyBeginAllowThreads();
35283 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
35284 wxPyEndAllowThreads(__tstate);
35285 if (PyErr_Occurred()) SWIG_fail;
35286 }
35287 {
35288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35289 }
35290 return resultobj;
35291 fail:
35292 return NULL;
35293 }
35294
35295
35296 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35297 PyObject *resultobj = 0;
35298 wxWindow *arg1 = (wxWindow *) 0 ;
35299 wxPoint *arg2 = 0 ;
35300 bool result;
35301 void *argp1 = 0 ;
35302 int res1 = 0 ;
35303 wxPoint temp2 ;
35304 PyObject * obj0 = 0 ;
35305 PyObject * obj1 = 0 ;
35306 char * kwnames[] = {
35307 (char *) "self",(char *) "pt", NULL
35308 };
35309
35310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
35311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35312 if (!SWIG_IsOK(res1)) {
35313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
35314 }
35315 arg1 = reinterpret_cast< wxWindow * >(argp1);
35316 {
35317 arg2 = &temp2;
35318 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35319 }
35320 {
35321 PyThreadState* __tstate = wxPyBeginAllowThreads();
35322 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
35323 wxPyEndAllowThreads(__tstate);
35324 if (PyErr_Occurred()) SWIG_fail;
35325 }
35326 {
35327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35328 }
35329 return resultobj;
35330 fail:
35331 return NULL;
35332 }
35333
35334
35335 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35336 PyObject *resultobj = 0;
35337 wxWindow *arg1 = (wxWindow *) 0 ;
35338 wxRect *arg2 = 0 ;
35339 bool result;
35340 void *argp1 = 0 ;
35341 int res1 = 0 ;
35342 wxRect temp2 ;
35343 PyObject * obj0 = 0 ;
35344 PyObject * obj1 = 0 ;
35345 char * kwnames[] = {
35346 (char *) "self",(char *) "rect", NULL
35347 };
35348
35349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
35350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35351 if (!SWIG_IsOK(res1)) {
35352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35353 }
35354 arg1 = reinterpret_cast< wxWindow * >(argp1);
35355 {
35356 arg2 = &temp2;
35357 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
35358 }
35359 {
35360 PyThreadState* __tstate = wxPyBeginAllowThreads();
35361 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
35362 wxPyEndAllowThreads(__tstate);
35363 if (PyErr_Occurred()) SWIG_fail;
35364 }
35365 {
35366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35367 }
35368 return resultobj;
35369 fail:
35370 return NULL;
35371 }
35372
35373
35374 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35375 PyObject *resultobj = 0;
35376 wxWindow *arg1 = (wxWindow *) 0 ;
35377 SwigValueWrapper<wxVisualAttributes > result;
35378 void *argp1 = 0 ;
35379 int res1 = 0 ;
35380 PyObject *swig_obj[1] ;
35381
35382 if (!args) SWIG_fail;
35383 swig_obj[0] = args;
35384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35385 if (!SWIG_IsOK(res1)) {
35386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
35387 }
35388 arg1 = reinterpret_cast< wxWindow * >(argp1);
35389 {
35390 PyThreadState* __tstate = wxPyBeginAllowThreads();
35391 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
35392 wxPyEndAllowThreads(__tstate);
35393 if (PyErr_Occurred()) SWIG_fail;
35394 }
35395 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35396 return resultobj;
35397 fail:
35398 return NULL;
35399 }
35400
35401
35402 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35403 PyObject *resultobj = 0;
35404 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
35405 SwigValueWrapper<wxVisualAttributes > result;
35406 int val1 ;
35407 int ecode1 = 0 ;
35408 PyObject * obj0 = 0 ;
35409 char * kwnames[] = {
35410 (char *) "variant", NULL
35411 };
35412
35413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
35414 if (obj0) {
35415 ecode1 = SWIG_AsVal_int(obj0, &val1);
35416 if (!SWIG_IsOK(ecode1)) {
35417 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
35418 }
35419 arg1 = static_cast< wxWindowVariant >(val1);
35420 }
35421 {
35422 if (!wxPyCheckForApp()) SWIG_fail;
35423 PyThreadState* __tstate = wxPyBeginAllowThreads();
35424 result = wxWindow::GetClassDefaultAttributes(arg1);
35425 wxPyEndAllowThreads(__tstate);
35426 if (PyErr_Occurred()) SWIG_fail;
35427 }
35428 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
35429 return resultobj;
35430 fail:
35431 return NULL;
35432 }
35433
35434
35435 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35436 PyObject *resultobj = 0;
35437 wxWindow *arg1 = (wxWindow *) 0 ;
35438 wxColour *arg2 = 0 ;
35439 bool result;
35440 void *argp1 = 0 ;
35441 int res1 = 0 ;
35442 wxColour temp2 ;
35443 PyObject * obj0 = 0 ;
35444 PyObject * obj1 = 0 ;
35445 char * kwnames[] = {
35446 (char *) "self",(char *) "colour", NULL
35447 };
35448
35449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35451 if (!SWIG_IsOK(res1)) {
35452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35453 }
35454 arg1 = reinterpret_cast< wxWindow * >(argp1);
35455 {
35456 arg2 = &temp2;
35457 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35458 }
35459 {
35460 PyThreadState* __tstate = wxPyBeginAllowThreads();
35461 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
35462 wxPyEndAllowThreads(__tstate);
35463 if (PyErr_Occurred()) SWIG_fail;
35464 }
35465 {
35466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35467 }
35468 return resultobj;
35469 fail:
35470 return NULL;
35471 }
35472
35473
35474 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35475 PyObject *resultobj = 0;
35476 wxWindow *arg1 = (wxWindow *) 0 ;
35477 wxColour *arg2 = 0 ;
35478 void *argp1 = 0 ;
35479 int res1 = 0 ;
35480 wxColour temp2 ;
35481 PyObject * obj0 = 0 ;
35482 PyObject * obj1 = 0 ;
35483 char * kwnames[] = {
35484 (char *) "self",(char *) "colour", NULL
35485 };
35486
35487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35489 if (!SWIG_IsOK(res1)) {
35490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35491 }
35492 arg1 = reinterpret_cast< wxWindow * >(argp1);
35493 {
35494 arg2 = &temp2;
35495 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35496 }
35497 {
35498 PyThreadState* __tstate = wxPyBeginAllowThreads();
35499 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
35500 wxPyEndAllowThreads(__tstate);
35501 if (PyErr_Occurred()) SWIG_fail;
35502 }
35503 resultobj = SWIG_Py_Void();
35504 return resultobj;
35505 fail:
35506 return NULL;
35507 }
35508
35509
35510 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35511 PyObject *resultobj = 0;
35512 wxWindow *arg1 = (wxWindow *) 0 ;
35513 wxColour *arg2 = 0 ;
35514 bool result;
35515 void *argp1 = 0 ;
35516 int res1 = 0 ;
35517 wxColour temp2 ;
35518 PyObject * obj0 = 0 ;
35519 PyObject * obj1 = 0 ;
35520 char * kwnames[] = {
35521 (char *) "self",(char *) "colour", NULL
35522 };
35523
35524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35526 if (!SWIG_IsOK(res1)) {
35527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35528 }
35529 arg1 = reinterpret_cast< wxWindow * >(argp1);
35530 {
35531 arg2 = &temp2;
35532 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35533 }
35534 {
35535 PyThreadState* __tstate = wxPyBeginAllowThreads();
35536 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
35537 wxPyEndAllowThreads(__tstate);
35538 if (PyErr_Occurred()) SWIG_fail;
35539 }
35540 {
35541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35542 }
35543 return resultobj;
35544 fail:
35545 return NULL;
35546 }
35547
35548
35549 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35550 PyObject *resultobj = 0;
35551 wxWindow *arg1 = (wxWindow *) 0 ;
35552 wxColour *arg2 = 0 ;
35553 void *argp1 = 0 ;
35554 int res1 = 0 ;
35555 wxColour temp2 ;
35556 PyObject * obj0 = 0 ;
35557 PyObject * obj1 = 0 ;
35558 char * kwnames[] = {
35559 (char *) "self",(char *) "colour", NULL
35560 };
35561
35562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
35563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35564 if (!SWIG_IsOK(res1)) {
35565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
35566 }
35567 arg1 = reinterpret_cast< wxWindow * >(argp1);
35568 {
35569 arg2 = &temp2;
35570 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
35571 }
35572 {
35573 PyThreadState* __tstate = wxPyBeginAllowThreads();
35574 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
35575 wxPyEndAllowThreads(__tstate);
35576 if (PyErr_Occurred()) SWIG_fail;
35577 }
35578 resultobj = SWIG_Py_Void();
35579 return resultobj;
35580 fail:
35581 return NULL;
35582 }
35583
35584
35585 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35586 PyObject *resultobj = 0;
35587 wxWindow *arg1 = (wxWindow *) 0 ;
35588 wxColour result;
35589 void *argp1 = 0 ;
35590 int res1 = 0 ;
35591 PyObject *swig_obj[1] ;
35592
35593 if (!args) SWIG_fail;
35594 swig_obj[0] = args;
35595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35596 if (!SWIG_IsOK(res1)) {
35597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35598 }
35599 arg1 = reinterpret_cast< wxWindow * >(argp1);
35600 {
35601 PyThreadState* __tstate = wxPyBeginAllowThreads();
35602 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35603 wxPyEndAllowThreads(__tstate);
35604 if (PyErr_Occurred()) SWIG_fail;
35605 }
35606 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35607 return resultobj;
35608 fail:
35609 return NULL;
35610 }
35611
35612
35613 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35614 PyObject *resultobj = 0;
35615 wxWindow *arg1 = (wxWindow *) 0 ;
35616 wxColour result;
35617 void *argp1 = 0 ;
35618 int res1 = 0 ;
35619 PyObject *swig_obj[1] ;
35620
35621 if (!args) SWIG_fail;
35622 swig_obj[0] = args;
35623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35624 if (!SWIG_IsOK(res1)) {
35625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35626 }
35627 arg1 = reinterpret_cast< wxWindow * >(argp1);
35628 {
35629 PyThreadState* __tstate = wxPyBeginAllowThreads();
35630 result = ((wxWindow const *)arg1)->GetForegroundColour();
35631 wxPyEndAllowThreads(__tstate);
35632 if (PyErr_Occurred()) SWIG_fail;
35633 }
35634 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35635 return resultobj;
35636 fail:
35637 return NULL;
35638 }
35639
35640
35641 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35642 PyObject *resultobj = 0;
35643 wxWindow *arg1 = (wxWindow *) 0 ;
35644 bool result;
35645 void *argp1 = 0 ;
35646 int res1 = 0 ;
35647 PyObject *swig_obj[1] ;
35648
35649 if (!args) SWIG_fail;
35650 swig_obj[0] = args;
35651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35652 if (!SWIG_IsOK(res1)) {
35653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35654 }
35655 arg1 = reinterpret_cast< wxWindow * >(argp1);
35656 {
35657 PyThreadState* __tstate = wxPyBeginAllowThreads();
35658 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35659 wxPyEndAllowThreads(__tstate);
35660 if (PyErr_Occurred()) SWIG_fail;
35661 }
35662 {
35663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35664 }
35665 return resultobj;
35666 fail:
35667 return NULL;
35668 }
35669
35670
35671 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35672 PyObject *resultobj = 0;
35673 wxWindow *arg1 = (wxWindow *) 0 ;
35674 bool result;
35675 void *argp1 = 0 ;
35676 int res1 = 0 ;
35677 PyObject *swig_obj[1] ;
35678
35679 if (!args) SWIG_fail;
35680 swig_obj[0] = args;
35681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35682 if (!SWIG_IsOK(res1)) {
35683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35684 }
35685 arg1 = reinterpret_cast< wxWindow * >(argp1);
35686 {
35687 PyThreadState* __tstate = wxPyBeginAllowThreads();
35688 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35689 wxPyEndAllowThreads(__tstate);
35690 if (PyErr_Occurred()) SWIG_fail;
35691 }
35692 {
35693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35694 }
35695 return resultobj;
35696 fail:
35697 return NULL;
35698 }
35699
35700
35701 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35702 PyObject *resultobj = 0;
35703 wxWindow *arg1 = (wxWindow *) 0 ;
35704 wxBackgroundStyle arg2 ;
35705 bool result;
35706 void *argp1 = 0 ;
35707 int res1 = 0 ;
35708 int val2 ;
35709 int ecode2 = 0 ;
35710 PyObject * obj0 = 0 ;
35711 PyObject * obj1 = 0 ;
35712 char * kwnames[] = {
35713 (char *) "self",(char *) "style", NULL
35714 };
35715
35716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35718 if (!SWIG_IsOK(res1)) {
35719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35720 }
35721 arg1 = reinterpret_cast< wxWindow * >(argp1);
35722 ecode2 = SWIG_AsVal_int(obj1, &val2);
35723 if (!SWIG_IsOK(ecode2)) {
35724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35725 }
35726 arg2 = static_cast< wxBackgroundStyle >(val2);
35727 {
35728 PyThreadState* __tstate = wxPyBeginAllowThreads();
35729 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35730 wxPyEndAllowThreads(__tstate);
35731 if (PyErr_Occurred()) SWIG_fail;
35732 }
35733 {
35734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35735 }
35736 return resultobj;
35737 fail:
35738 return NULL;
35739 }
35740
35741
35742 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35743 PyObject *resultobj = 0;
35744 wxWindow *arg1 = (wxWindow *) 0 ;
35745 wxBackgroundStyle result;
35746 void *argp1 = 0 ;
35747 int res1 = 0 ;
35748 PyObject *swig_obj[1] ;
35749
35750 if (!args) SWIG_fail;
35751 swig_obj[0] = args;
35752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35753 if (!SWIG_IsOK(res1)) {
35754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35755 }
35756 arg1 = reinterpret_cast< wxWindow * >(argp1);
35757 {
35758 PyThreadState* __tstate = wxPyBeginAllowThreads();
35759 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35760 wxPyEndAllowThreads(__tstate);
35761 if (PyErr_Occurred()) SWIG_fail;
35762 }
35763 resultobj = SWIG_From_int(static_cast< int >(result));
35764 return resultobj;
35765 fail:
35766 return NULL;
35767 }
35768
35769
35770 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35771 PyObject *resultobj = 0;
35772 wxWindow *arg1 = (wxWindow *) 0 ;
35773 bool result;
35774 void *argp1 = 0 ;
35775 int res1 = 0 ;
35776 PyObject *swig_obj[1] ;
35777
35778 if (!args) SWIG_fail;
35779 swig_obj[0] = args;
35780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35781 if (!SWIG_IsOK(res1)) {
35782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35783 }
35784 arg1 = reinterpret_cast< wxWindow * >(argp1);
35785 {
35786 PyThreadState* __tstate = wxPyBeginAllowThreads();
35787 result = (bool)(arg1)->HasTransparentBackground();
35788 wxPyEndAllowThreads(__tstate);
35789 if (PyErr_Occurred()) SWIG_fail;
35790 }
35791 {
35792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35793 }
35794 return resultobj;
35795 fail:
35796 return NULL;
35797 }
35798
35799
35800 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35801 PyObject *resultobj = 0;
35802 wxWindow *arg1 = (wxWindow *) 0 ;
35803 wxCursor *arg2 = 0 ;
35804 bool result;
35805 void *argp1 = 0 ;
35806 int res1 = 0 ;
35807 void *argp2 = 0 ;
35808 int res2 = 0 ;
35809 PyObject * obj0 = 0 ;
35810 PyObject * obj1 = 0 ;
35811 char * kwnames[] = {
35812 (char *) "self",(char *) "cursor", NULL
35813 };
35814
35815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35817 if (!SWIG_IsOK(res1)) {
35818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35819 }
35820 arg1 = reinterpret_cast< wxWindow * >(argp1);
35821 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35822 if (!SWIG_IsOK(res2)) {
35823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35824 }
35825 if (!argp2) {
35826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35827 }
35828 arg2 = reinterpret_cast< wxCursor * >(argp2);
35829 {
35830 PyThreadState* __tstate = wxPyBeginAllowThreads();
35831 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35832 wxPyEndAllowThreads(__tstate);
35833 if (PyErr_Occurred()) SWIG_fail;
35834 }
35835 {
35836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35837 }
35838 return resultobj;
35839 fail:
35840 return NULL;
35841 }
35842
35843
35844 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35845 PyObject *resultobj = 0;
35846 wxWindow *arg1 = (wxWindow *) 0 ;
35847 wxCursor result;
35848 void *argp1 = 0 ;
35849 int res1 = 0 ;
35850 PyObject *swig_obj[1] ;
35851
35852 if (!args) SWIG_fail;
35853 swig_obj[0] = args;
35854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35855 if (!SWIG_IsOK(res1)) {
35856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35857 }
35858 arg1 = reinterpret_cast< wxWindow * >(argp1);
35859 {
35860 PyThreadState* __tstate = wxPyBeginAllowThreads();
35861 result = (arg1)->GetCursor();
35862 wxPyEndAllowThreads(__tstate);
35863 if (PyErr_Occurred()) SWIG_fail;
35864 }
35865 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35866 return resultobj;
35867 fail:
35868 return NULL;
35869 }
35870
35871
35872 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35873 PyObject *resultobj = 0;
35874 wxWindow *arg1 = (wxWindow *) 0 ;
35875 wxFont *arg2 = 0 ;
35876 bool result;
35877 void *argp1 = 0 ;
35878 int res1 = 0 ;
35879 void *argp2 = 0 ;
35880 int res2 = 0 ;
35881 PyObject * obj0 = 0 ;
35882 PyObject * obj1 = 0 ;
35883 char * kwnames[] = {
35884 (char *) "self",(char *) "font", NULL
35885 };
35886
35887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35889 if (!SWIG_IsOK(res1)) {
35890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35891 }
35892 arg1 = reinterpret_cast< wxWindow * >(argp1);
35893 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35894 if (!SWIG_IsOK(res2)) {
35895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35896 }
35897 if (!argp2) {
35898 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35899 }
35900 arg2 = reinterpret_cast< wxFont * >(argp2);
35901 {
35902 PyThreadState* __tstate = wxPyBeginAllowThreads();
35903 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35904 wxPyEndAllowThreads(__tstate);
35905 if (PyErr_Occurred()) SWIG_fail;
35906 }
35907 {
35908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35909 }
35910 return resultobj;
35911 fail:
35912 return NULL;
35913 }
35914
35915
35916 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35917 PyObject *resultobj = 0;
35918 wxWindow *arg1 = (wxWindow *) 0 ;
35919 wxFont *arg2 = 0 ;
35920 void *argp1 = 0 ;
35921 int res1 = 0 ;
35922 void *argp2 = 0 ;
35923 int res2 = 0 ;
35924 PyObject * obj0 = 0 ;
35925 PyObject * obj1 = 0 ;
35926 char * kwnames[] = {
35927 (char *) "self",(char *) "font", NULL
35928 };
35929
35930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35932 if (!SWIG_IsOK(res1)) {
35933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35934 }
35935 arg1 = reinterpret_cast< wxWindow * >(argp1);
35936 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35937 if (!SWIG_IsOK(res2)) {
35938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35939 }
35940 if (!argp2) {
35941 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35942 }
35943 arg2 = reinterpret_cast< wxFont * >(argp2);
35944 {
35945 PyThreadState* __tstate = wxPyBeginAllowThreads();
35946 (arg1)->SetOwnFont((wxFont const &)*arg2);
35947 wxPyEndAllowThreads(__tstate);
35948 if (PyErr_Occurred()) SWIG_fail;
35949 }
35950 resultobj = SWIG_Py_Void();
35951 return resultobj;
35952 fail:
35953 return NULL;
35954 }
35955
35956
35957 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35958 PyObject *resultobj = 0;
35959 wxWindow *arg1 = (wxWindow *) 0 ;
35960 wxFont result;
35961 void *argp1 = 0 ;
35962 int res1 = 0 ;
35963 PyObject *swig_obj[1] ;
35964
35965 if (!args) SWIG_fail;
35966 swig_obj[0] = args;
35967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35968 if (!SWIG_IsOK(res1)) {
35969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35970 }
35971 arg1 = reinterpret_cast< wxWindow * >(argp1);
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 result = (arg1)->GetFont();
35975 wxPyEndAllowThreads(__tstate);
35976 if (PyErr_Occurred()) SWIG_fail;
35977 }
35978 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35979 return resultobj;
35980 fail:
35981 return NULL;
35982 }
35983
35984
35985 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35986 PyObject *resultobj = 0;
35987 wxWindow *arg1 = (wxWindow *) 0 ;
35988 wxCaret *arg2 = (wxCaret *) 0 ;
35989 void *argp1 = 0 ;
35990 int res1 = 0 ;
35991 int res2 = 0 ;
35992 PyObject * obj0 = 0 ;
35993 PyObject * obj1 = 0 ;
35994 char * kwnames[] = {
35995 (char *) "self",(char *) "caret", NULL
35996 };
35997
35998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36000 if (!SWIG_IsOK(res1)) {
36001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
36002 }
36003 arg1 = reinterpret_cast< wxWindow * >(argp1);
36004 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
36005 if (!SWIG_IsOK(res2)) {
36006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
36007 }
36008 {
36009 PyThreadState* __tstate = wxPyBeginAllowThreads();
36010 (arg1)->SetCaret(arg2);
36011 wxPyEndAllowThreads(__tstate);
36012 if (PyErr_Occurred()) SWIG_fail;
36013 }
36014 resultobj = SWIG_Py_Void();
36015 return resultobj;
36016 fail:
36017 return NULL;
36018 }
36019
36020
36021 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36022 PyObject *resultobj = 0;
36023 wxWindow *arg1 = (wxWindow *) 0 ;
36024 wxCaret *result = 0 ;
36025 void *argp1 = 0 ;
36026 int res1 = 0 ;
36027 PyObject *swig_obj[1] ;
36028
36029 if (!args) SWIG_fail;
36030 swig_obj[0] = args;
36031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36032 if (!SWIG_IsOK(res1)) {
36033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
36034 }
36035 arg1 = reinterpret_cast< wxWindow * >(argp1);
36036 {
36037 PyThreadState* __tstate = wxPyBeginAllowThreads();
36038 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
36039 wxPyEndAllowThreads(__tstate);
36040 if (PyErr_Occurred()) SWIG_fail;
36041 }
36042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
36043 return resultobj;
36044 fail:
36045 return NULL;
36046 }
36047
36048
36049 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36050 PyObject *resultobj = 0;
36051 wxWindow *arg1 = (wxWindow *) 0 ;
36052 int result;
36053 void *argp1 = 0 ;
36054 int res1 = 0 ;
36055 PyObject *swig_obj[1] ;
36056
36057 if (!args) SWIG_fail;
36058 swig_obj[0] = args;
36059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36060 if (!SWIG_IsOK(res1)) {
36061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
36062 }
36063 arg1 = reinterpret_cast< wxWindow * >(argp1);
36064 {
36065 PyThreadState* __tstate = wxPyBeginAllowThreads();
36066 result = (int)((wxWindow const *)arg1)->GetCharHeight();
36067 wxPyEndAllowThreads(__tstate);
36068 if (PyErr_Occurred()) SWIG_fail;
36069 }
36070 resultobj = SWIG_From_int(static_cast< int >(result));
36071 return resultobj;
36072 fail:
36073 return NULL;
36074 }
36075
36076
36077 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36078 PyObject *resultobj = 0;
36079 wxWindow *arg1 = (wxWindow *) 0 ;
36080 int result;
36081 void *argp1 = 0 ;
36082 int res1 = 0 ;
36083 PyObject *swig_obj[1] ;
36084
36085 if (!args) SWIG_fail;
36086 swig_obj[0] = args;
36087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36088 if (!SWIG_IsOK(res1)) {
36089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
36090 }
36091 arg1 = reinterpret_cast< wxWindow * >(argp1);
36092 {
36093 PyThreadState* __tstate = wxPyBeginAllowThreads();
36094 result = (int)((wxWindow const *)arg1)->GetCharWidth();
36095 wxPyEndAllowThreads(__tstate);
36096 if (PyErr_Occurred()) SWIG_fail;
36097 }
36098 resultobj = SWIG_From_int(static_cast< int >(result));
36099 return resultobj;
36100 fail:
36101 return NULL;
36102 }
36103
36104
36105 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36106 PyObject *resultobj = 0;
36107 wxWindow *arg1 = (wxWindow *) 0 ;
36108 wxString *arg2 = 0 ;
36109 int *arg3 = (int *) 0 ;
36110 int *arg4 = (int *) 0 ;
36111 void *argp1 = 0 ;
36112 int res1 = 0 ;
36113 bool temp2 = false ;
36114 int temp3 ;
36115 int res3 = SWIG_TMPOBJ ;
36116 int temp4 ;
36117 int res4 = SWIG_TMPOBJ ;
36118 PyObject * obj0 = 0 ;
36119 PyObject * obj1 = 0 ;
36120 char * kwnames[] = {
36121 (char *) "self",(char *) "string", NULL
36122 };
36123
36124 arg3 = &temp3;
36125 arg4 = &temp4;
36126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
36127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36128 if (!SWIG_IsOK(res1)) {
36129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36130 }
36131 arg1 = reinterpret_cast< wxWindow * >(argp1);
36132 {
36133 arg2 = wxString_in_helper(obj1);
36134 if (arg2 == NULL) SWIG_fail;
36135 temp2 = true;
36136 }
36137 {
36138 PyThreadState* __tstate = wxPyBeginAllowThreads();
36139 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
36140 wxPyEndAllowThreads(__tstate);
36141 if (PyErr_Occurred()) SWIG_fail;
36142 }
36143 resultobj = SWIG_Py_Void();
36144 if (SWIG_IsTmpObj(res3)) {
36145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36146 } else {
36147 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36149 }
36150 if (SWIG_IsTmpObj(res4)) {
36151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36152 } else {
36153 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36154 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36155 }
36156 {
36157 if (temp2)
36158 delete arg2;
36159 }
36160 return resultobj;
36161 fail:
36162 {
36163 if (temp2)
36164 delete arg2;
36165 }
36166 return NULL;
36167 }
36168
36169
36170 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36171 PyObject *resultobj = 0;
36172 wxWindow *arg1 = (wxWindow *) 0 ;
36173 wxString *arg2 = 0 ;
36174 int *arg3 = (int *) 0 ;
36175 int *arg4 = (int *) 0 ;
36176 int *arg5 = (int *) 0 ;
36177 int *arg6 = (int *) 0 ;
36178 wxFont *arg7 = (wxFont *) NULL ;
36179 void *argp1 = 0 ;
36180 int res1 = 0 ;
36181 bool temp2 = false ;
36182 int temp3 ;
36183 int res3 = SWIG_TMPOBJ ;
36184 int temp4 ;
36185 int res4 = SWIG_TMPOBJ ;
36186 int temp5 ;
36187 int res5 = SWIG_TMPOBJ ;
36188 int temp6 ;
36189 int res6 = SWIG_TMPOBJ ;
36190 void *argp7 = 0 ;
36191 int res7 = 0 ;
36192 PyObject * obj0 = 0 ;
36193 PyObject * obj1 = 0 ;
36194 PyObject * obj2 = 0 ;
36195 char * kwnames[] = {
36196 (char *) "self",(char *) "string",(char *) "font", NULL
36197 };
36198
36199 arg3 = &temp3;
36200 arg4 = &temp4;
36201 arg5 = &temp5;
36202 arg6 = &temp6;
36203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36205 if (!SWIG_IsOK(res1)) {
36206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
36207 }
36208 arg1 = reinterpret_cast< wxWindow * >(argp1);
36209 {
36210 arg2 = wxString_in_helper(obj1);
36211 if (arg2 == NULL) SWIG_fail;
36212 temp2 = true;
36213 }
36214 if (obj2) {
36215 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
36216 if (!SWIG_IsOK(res7)) {
36217 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
36218 }
36219 arg7 = reinterpret_cast< wxFont * >(argp7);
36220 }
36221 {
36222 PyThreadState* __tstate = wxPyBeginAllowThreads();
36223 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
36224 wxPyEndAllowThreads(__tstate);
36225 if (PyErr_Occurred()) SWIG_fail;
36226 }
36227 resultobj = SWIG_Py_Void();
36228 if (SWIG_IsTmpObj(res3)) {
36229 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36230 } else {
36231 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36233 }
36234 if (SWIG_IsTmpObj(res4)) {
36235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
36236 } else {
36237 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
36239 }
36240 if (SWIG_IsTmpObj(res5)) {
36241 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
36242 } else {
36243 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36244 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
36245 }
36246 if (SWIG_IsTmpObj(res6)) {
36247 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
36248 } else {
36249 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
36251 }
36252 {
36253 if (temp2)
36254 delete arg2;
36255 }
36256 return resultobj;
36257 fail:
36258 {
36259 if (temp2)
36260 delete arg2;
36261 }
36262 return NULL;
36263 }
36264
36265
36266 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36267 PyObject *resultobj = 0;
36268 wxWindow *arg1 = (wxWindow *) 0 ;
36269 int *arg2 = (int *) 0 ;
36270 int *arg3 = (int *) 0 ;
36271 void *argp1 = 0 ;
36272 int res1 = 0 ;
36273 int temp2 ;
36274 int res2 = 0 ;
36275 int temp3 ;
36276 int res3 = 0 ;
36277 PyObject * obj0 = 0 ;
36278 PyObject * obj1 = 0 ;
36279 PyObject * obj2 = 0 ;
36280 char * kwnames[] = {
36281 (char *) "self",(char *) "x",(char *) "y", NULL
36282 };
36283
36284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36286 if (!SWIG_IsOK(res1)) {
36287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36288 }
36289 arg1 = reinterpret_cast< wxWindow * >(argp1);
36290 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36291 int val;
36292 int ecode = SWIG_AsVal_int(obj1, &val);
36293 if (!SWIG_IsOK(ecode)) {
36294 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
36295 }
36296 temp2 = static_cast< int >(val);
36297 arg2 = &temp2;
36298 res2 = SWIG_AddTmpMask(ecode);
36299 }
36300 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36301 int val;
36302 int ecode = SWIG_AsVal_int(obj2, &val);
36303 if (!SWIG_IsOK(ecode)) {
36304 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
36305 }
36306 temp3 = static_cast< int >(val);
36307 arg3 = &temp3;
36308 res3 = SWIG_AddTmpMask(ecode);
36309 }
36310 {
36311 PyThreadState* __tstate = wxPyBeginAllowThreads();
36312 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
36313 wxPyEndAllowThreads(__tstate);
36314 if (PyErr_Occurred()) SWIG_fail;
36315 }
36316 resultobj = SWIG_Py_Void();
36317 if (SWIG_IsTmpObj(res2)) {
36318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36319 } else {
36320 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36321 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36322 }
36323 if (SWIG_IsTmpObj(res3)) {
36324 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36325 } else {
36326 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36328 }
36329 return resultobj;
36330 fail:
36331 return NULL;
36332 }
36333
36334
36335 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36336 PyObject *resultobj = 0;
36337 wxWindow *arg1 = (wxWindow *) 0 ;
36338 int *arg2 = (int *) 0 ;
36339 int *arg3 = (int *) 0 ;
36340 void *argp1 = 0 ;
36341 int res1 = 0 ;
36342 int temp2 ;
36343 int res2 = 0 ;
36344 int temp3 ;
36345 int res3 = 0 ;
36346 PyObject * obj0 = 0 ;
36347 PyObject * obj1 = 0 ;
36348 PyObject * obj2 = 0 ;
36349 char * kwnames[] = {
36350 (char *) "self",(char *) "x",(char *) "y", NULL
36351 };
36352
36353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36355 if (!SWIG_IsOK(res1)) {
36356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36357 }
36358 arg1 = reinterpret_cast< wxWindow * >(argp1);
36359 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
36360 int val;
36361 int ecode = SWIG_AsVal_int(obj1, &val);
36362 if (!SWIG_IsOK(ecode)) {
36363 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
36364 }
36365 temp2 = static_cast< int >(val);
36366 arg2 = &temp2;
36367 res2 = SWIG_AddTmpMask(ecode);
36368 }
36369 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
36370 int val;
36371 int ecode = SWIG_AsVal_int(obj2, &val);
36372 if (!SWIG_IsOK(ecode)) {
36373 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
36374 }
36375 temp3 = static_cast< int >(val);
36376 arg3 = &temp3;
36377 res3 = SWIG_AddTmpMask(ecode);
36378 }
36379 {
36380 PyThreadState* __tstate = wxPyBeginAllowThreads();
36381 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
36382 wxPyEndAllowThreads(__tstate);
36383 if (PyErr_Occurred()) SWIG_fail;
36384 }
36385 resultobj = SWIG_Py_Void();
36386 if (SWIG_IsTmpObj(res2)) {
36387 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36388 } else {
36389 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36390 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36391 }
36392 if (SWIG_IsTmpObj(res3)) {
36393 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36394 } else {
36395 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36396 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36397 }
36398 return resultobj;
36399 fail:
36400 return NULL;
36401 }
36402
36403
36404 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36405 PyObject *resultobj = 0;
36406 wxWindow *arg1 = (wxWindow *) 0 ;
36407 wxPoint *arg2 = 0 ;
36408 wxPoint result;
36409 void *argp1 = 0 ;
36410 int res1 = 0 ;
36411 wxPoint temp2 ;
36412 PyObject * obj0 = 0 ;
36413 PyObject * obj1 = 0 ;
36414 char * kwnames[] = {
36415 (char *) "self",(char *) "pt", NULL
36416 };
36417
36418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
36419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36420 if (!SWIG_IsOK(res1)) {
36421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36422 }
36423 arg1 = reinterpret_cast< wxWindow * >(argp1);
36424 {
36425 arg2 = &temp2;
36426 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36427 }
36428 {
36429 PyThreadState* __tstate = wxPyBeginAllowThreads();
36430 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
36431 wxPyEndAllowThreads(__tstate);
36432 if (PyErr_Occurred()) SWIG_fail;
36433 }
36434 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36435 return resultobj;
36436 fail:
36437 return NULL;
36438 }
36439
36440
36441 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36442 PyObject *resultobj = 0;
36443 wxWindow *arg1 = (wxWindow *) 0 ;
36444 wxPoint *arg2 = 0 ;
36445 wxPoint result;
36446 void *argp1 = 0 ;
36447 int res1 = 0 ;
36448 wxPoint temp2 ;
36449 PyObject * obj0 = 0 ;
36450 PyObject * obj1 = 0 ;
36451 char * kwnames[] = {
36452 (char *) "self",(char *) "pt", NULL
36453 };
36454
36455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
36456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36457 if (!SWIG_IsOK(res1)) {
36458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
36459 }
36460 arg1 = reinterpret_cast< wxWindow * >(argp1);
36461 {
36462 arg2 = &temp2;
36463 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36464 }
36465 {
36466 PyThreadState* __tstate = wxPyBeginAllowThreads();
36467 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
36468 wxPyEndAllowThreads(__tstate);
36469 if (PyErr_Occurred()) SWIG_fail;
36470 }
36471 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
36472 return resultobj;
36473 fail:
36474 return NULL;
36475 }
36476
36477
36478 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36479 PyObject *resultobj = 0;
36480 wxWindow *arg1 = (wxWindow *) 0 ;
36481 int arg2 ;
36482 int arg3 ;
36483 wxHitTest result;
36484 void *argp1 = 0 ;
36485 int res1 = 0 ;
36486 int val2 ;
36487 int ecode2 = 0 ;
36488 int val3 ;
36489 int ecode3 = 0 ;
36490 PyObject * obj0 = 0 ;
36491 PyObject * obj1 = 0 ;
36492 PyObject * obj2 = 0 ;
36493 char * kwnames[] = {
36494 (char *) "self",(char *) "x",(char *) "y", NULL
36495 };
36496
36497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36499 if (!SWIG_IsOK(res1)) {
36500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
36501 }
36502 arg1 = reinterpret_cast< wxWindow * >(argp1);
36503 ecode2 = SWIG_AsVal_int(obj1, &val2);
36504 if (!SWIG_IsOK(ecode2)) {
36505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
36506 }
36507 arg2 = static_cast< int >(val2);
36508 ecode3 = SWIG_AsVal_int(obj2, &val3);
36509 if (!SWIG_IsOK(ecode3)) {
36510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
36511 }
36512 arg3 = static_cast< int >(val3);
36513 {
36514 PyThreadState* __tstate = wxPyBeginAllowThreads();
36515 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
36516 wxPyEndAllowThreads(__tstate);
36517 if (PyErr_Occurred()) SWIG_fail;
36518 }
36519 resultobj = SWIG_From_int(static_cast< int >(result));
36520 return resultobj;
36521 fail:
36522 return NULL;
36523 }
36524
36525
36526 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36527 PyObject *resultobj = 0;
36528 wxWindow *arg1 = (wxWindow *) 0 ;
36529 wxPoint *arg2 = 0 ;
36530 wxHitTest result;
36531 void *argp1 = 0 ;
36532 int res1 = 0 ;
36533 wxPoint temp2 ;
36534 PyObject * obj0 = 0 ;
36535 PyObject * obj1 = 0 ;
36536 char * kwnames[] = {
36537 (char *) "self",(char *) "pt", NULL
36538 };
36539
36540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
36541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36542 if (!SWIG_IsOK(res1)) {
36543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
36544 }
36545 arg1 = reinterpret_cast< wxWindow * >(argp1);
36546 {
36547 arg2 = &temp2;
36548 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
36549 }
36550 {
36551 PyThreadState* __tstate = wxPyBeginAllowThreads();
36552 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
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__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36564 PyObject *resultobj = 0;
36565 wxWindow *arg1 = (wxWindow *) 0 ;
36566 long arg2 ;
36567 wxBorder result;
36568 void *argp1 = 0 ;
36569 int res1 = 0 ;
36570 long val2 ;
36571 int ecode2 = 0 ;
36572
36573 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
36574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36575 if (!SWIG_IsOK(res1)) {
36576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36577 }
36578 arg1 = reinterpret_cast< wxWindow * >(argp1);
36579 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
36580 if (!SWIG_IsOK(ecode2)) {
36581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
36582 }
36583 arg2 = static_cast< long >(val2);
36584 {
36585 PyThreadState* __tstate = wxPyBeginAllowThreads();
36586 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36587 wxPyEndAllowThreads(__tstate);
36588 if (PyErr_Occurred()) SWIG_fail;
36589 }
36590 resultobj = SWIG_From_int(static_cast< int >(result));
36591 return resultobj;
36592 fail:
36593 return NULL;
36594 }
36595
36596
36597 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36598 PyObject *resultobj = 0;
36599 wxWindow *arg1 = (wxWindow *) 0 ;
36600 wxBorder result;
36601 void *argp1 = 0 ;
36602 int res1 = 0 ;
36603
36604 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36606 if (!SWIG_IsOK(res1)) {
36607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36608 }
36609 arg1 = reinterpret_cast< wxWindow * >(argp1);
36610 {
36611 PyThreadState* __tstate = wxPyBeginAllowThreads();
36612 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36613 wxPyEndAllowThreads(__tstate);
36614 if (PyErr_Occurred()) SWIG_fail;
36615 }
36616 resultobj = SWIG_From_int(static_cast< int >(result));
36617 return resultobj;
36618 fail:
36619 return NULL;
36620 }
36621
36622
36623 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36624 int argc;
36625 PyObject *argv[3];
36626
36627 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36628 --argc;
36629 if (argc == 1) {
36630 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36631 }
36632 if (argc == 2) {
36633 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36634 }
36635
36636 fail:
36637 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36638 return NULL;
36639 }
36640
36641
36642 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36643 PyObject *resultobj = 0;
36644 wxWindow *arg1 = (wxWindow *) 0 ;
36645 long arg2 = (long) wxUPDATE_UI_NONE ;
36646 void *argp1 = 0 ;
36647 int res1 = 0 ;
36648 long val2 ;
36649 int ecode2 = 0 ;
36650 PyObject * obj0 = 0 ;
36651 PyObject * obj1 = 0 ;
36652 char * kwnames[] = {
36653 (char *) "self",(char *) "flags", NULL
36654 };
36655
36656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36658 if (!SWIG_IsOK(res1)) {
36659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36660 }
36661 arg1 = reinterpret_cast< wxWindow * >(argp1);
36662 if (obj1) {
36663 ecode2 = SWIG_AsVal_long(obj1, &val2);
36664 if (!SWIG_IsOK(ecode2)) {
36665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36666 }
36667 arg2 = static_cast< long >(val2);
36668 }
36669 {
36670 PyThreadState* __tstate = wxPyBeginAllowThreads();
36671 (arg1)->UpdateWindowUI(arg2);
36672 wxPyEndAllowThreads(__tstate);
36673 if (PyErr_Occurred()) SWIG_fail;
36674 }
36675 resultobj = SWIG_Py_Void();
36676 return resultobj;
36677 fail:
36678 return NULL;
36679 }
36680
36681
36682 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36683 PyObject *resultobj = 0;
36684 wxWindow *arg1 = (wxWindow *) 0 ;
36685 wxMenu *arg2 = (wxMenu *) 0 ;
36686 int arg3 = (int) -1 ;
36687 int arg4 = (int) -1 ;
36688 bool result;
36689 void *argp1 = 0 ;
36690 int res1 = 0 ;
36691 void *argp2 = 0 ;
36692 int res2 = 0 ;
36693 int val3 ;
36694 int ecode3 = 0 ;
36695 int val4 ;
36696 int ecode4 = 0 ;
36697 PyObject * obj0 = 0 ;
36698 PyObject * obj1 = 0 ;
36699 PyObject * obj2 = 0 ;
36700 PyObject * obj3 = 0 ;
36701 char * kwnames[] = {
36702 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36703 };
36704
36705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36707 if (!SWIG_IsOK(res1)) {
36708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36709 }
36710 arg1 = reinterpret_cast< wxWindow * >(argp1);
36711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36712 if (!SWIG_IsOK(res2)) {
36713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36714 }
36715 arg2 = reinterpret_cast< wxMenu * >(argp2);
36716 if (obj2) {
36717 ecode3 = SWIG_AsVal_int(obj2, &val3);
36718 if (!SWIG_IsOK(ecode3)) {
36719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36720 }
36721 arg3 = static_cast< int >(val3);
36722 }
36723 if (obj3) {
36724 ecode4 = SWIG_AsVal_int(obj3, &val4);
36725 if (!SWIG_IsOK(ecode4)) {
36726 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36727 }
36728 arg4 = static_cast< int >(val4);
36729 }
36730 {
36731 PyThreadState* __tstate = wxPyBeginAllowThreads();
36732 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36733 wxPyEndAllowThreads(__tstate);
36734 if (PyErr_Occurred()) SWIG_fail;
36735 }
36736 {
36737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36738 }
36739 return resultobj;
36740 fail:
36741 return NULL;
36742 }
36743
36744
36745 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36746 PyObject *resultobj = 0;
36747 wxWindow *arg1 = (wxWindow *) 0 ;
36748 wxMenu *arg2 = (wxMenu *) 0 ;
36749 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36750 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36751 bool result;
36752 void *argp1 = 0 ;
36753 int res1 = 0 ;
36754 void *argp2 = 0 ;
36755 int res2 = 0 ;
36756 wxPoint temp3 ;
36757 PyObject * obj0 = 0 ;
36758 PyObject * obj1 = 0 ;
36759 PyObject * obj2 = 0 ;
36760 char * kwnames[] = {
36761 (char *) "self",(char *) "menu",(char *) "pos", NULL
36762 };
36763
36764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36766 if (!SWIG_IsOK(res1)) {
36767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36768 }
36769 arg1 = reinterpret_cast< wxWindow * >(argp1);
36770 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36771 if (!SWIG_IsOK(res2)) {
36772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36773 }
36774 arg2 = reinterpret_cast< wxMenu * >(argp2);
36775 if (obj2) {
36776 {
36777 arg3 = &temp3;
36778 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36779 }
36780 }
36781 {
36782 PyThreadState* __tstate = wxPyBeginAllowThreads();
36783 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36784 wxPyEndAllowThreads(__tstate);
36785 if (PyErr_Occurred()) SWIG_fail;
36786 }
36787 {
36788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36789 }
36790 return resultobj;
36791 fail:
36792 return NULL;
36793 }
36794
36795
36796 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36797 PyObject *resultobj = 0;
36798 wxWindow *arg1 = (wxWindow *) 0 ;
36799 bool result;
36800 void *argp1 = 0 ;
36801 int res1 = 0 ;
36802 PyObject *swig_obj[1] ;
36803
36804 if (!args) SWIG_fail;
36805 swig_obj[0] = args;
36806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36807 if (!SWIG_IsOK(res1)) {
36808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36809 }
36810 arg1 = reinterpret_cast< wxWindow * >(argp1);
36811 {
36812 PyThreadState* __tstate = wxPyBeginAllowThreads();
36813 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36814 wxPyEndAllowThreads(__tstate);
36815 if (PyErr_Occurred()) SWIG_fail;
36816 }
36817 {
36818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36819 }
36820 return resultobj;
36821 fail:
36822 return NULL;
36823 }
36824
36825
36826 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36827 PyObject *resultobj = 0;
36828 wxWindow *arg1 = (wxWindow *) 0 ;
36829 long result;
36830 void *argp1 = 0 ;
36831 int res1 = 0 ;
36832 PyObject *swig_obj[1] ;
36833
36834 if (!args) SWIG_fail;
36835 swig_obj[0] = args;
36836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36837 if (!SWIG_IsOK(res1)) {
36838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36839 }
36840 arg1 = reinterpret_cast< wxWindow * >(argp1);
36841 {
36842 PyThreadState* __tstate = wxPyBeginAllowThreads();
36843 result = (long)wxWindow_GetHandle(arg1);
36844 wxPyEndAllowThreads(__tstate);
36845 if (PyErr_Occurred()) SWIG_fail;
36846 }
36847 resultobj = SWIG_From_long(static_cast< long >(result));
36848 return resultobj;
36849 fail:
36850 return NULL;
36851 }
36852
36853
36854 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36855 PyObject *resultobj = 0;
36856 wxWindow *arg1 = (wxWindow *) 0 ;
36857 long arg2 ;
36858 void *argp1 = 0 ;
36859 int res1 = 0 ;
36860 long val2 ;
36861 int ecode2 = 0 ;
36862 PyObject * obj0 = 0 ;
36863 PyObject * obj1 = 0 ;
36864 char * kwnames[] = {
36865 (char *) "self",(char *) "handle", NULL
36866 };
36867
36868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36870 if (!SWIG_IsOK(res1)) {
36871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36872 }
36873 arg1 = reinterpret_cast< wxWindow * >(argp1);
36874 ecode2 = SWIG_AsVal_long(obj1, &val2);
36875 if (!SWIG_IsOK(ecode2)) {
36876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36877 }
36878 arg2 = static_cast< long >(val2);
36879 {
36880 PyThreadState* __tstate = wxPyBeginAllowThreads();
36881 wxWindow_AssociateHandle(arg1,arg2);
36882 wxPyEndAllowThreads(__tstate);
36883 if (PyErr_Occurred()) SWIG_fail;
36884 }
36885 resultobj = SWIG_Py_Void();
36886 return resultobj;
36887 fail:
36888 return NULL;
36889 }
36890
36891
36892 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36893 PyObject *resultobj = 0;
36894 wxWindow *arg1 = (wxWindow *) 0 ;
36895 void *argp1 = 0 ;
36896 int res1 = 0 ;
36897 PyObject *swig_obj[1] ;
36898
36899 if (!args) SWIG_fail;
36900 swig_obj[0] = args;
36901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36902 if (!SWIG_IsOK(res1)) {
36903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36904 }
36905 arg1 = reinterpret_cast< wxWindow * >(argp1);
36906 {
36907 PyThreadState* __tstate = wxPyBeginAllowThreads();
36908 (arg1)->DissociateHandle();
36909 wxPyEndAllowThreads(__tstate);
36910 if (PyErr_Occurred()) SWIG_fail;
36911 }
36912 resultobj = SWIG_Py_Void();
36913 return resultobj;
36914 fail:
36915 return NULL;
36916 }
36917
36918
36919 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36920 PyObject *resultobj = 0;
36921 wxWindow *arg1 = (wxWindow *) 0 ;
36922 int arg2 ;
36923 bool result;
36924 void *argp1 = 0 ;
36925 int res1 = 0 ;
36926 int val2 ;
36927 int ecode2 = 0 ;
36928 PyObject * obj0 = 0 ;
36929 PyObject * obj1 = 0 ;
36930 char * kwnames[] = {
36931 (char *) "self",(char *) "orient", NULL
36932 };
36933
36934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36936 if (!SWIG_IsOK(res1)) {
36937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36938 }
36939 arg1 = reinterpret_cast< wxWindow * >(argp1);
36940 ecode2 = SWIG_AsVal_int(obj1, &val2);
36941 if (!SWIG_IsOK(ecode2)) {
36942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36943 }
36944 arg2 = static_cast< int >(val2);
36945 {
36946 PyThreadState* __tstate = wxPyBeginAllowThreads();
36947 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36948 wxPyEndAllowThreads(__tstate);
36949 if (PyErr_Occurred()) SWIG_fail;
36950 }
36951 {
36952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36953 }
36954 return resultobj;
36955 fail:
36956 return NULL;
36957 }
36958
36959
36960 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36961 PyObject *resultobj = 0;
36962 wxWindow *arg1 = (wxWindow *) 0 ;
36963 int arg2 ;
36964 int arg3 ;
36965 int arg4 ;
36966 int arg5 ;
36967 bool arg6 = (bool) true ;
36968 void *argp1 = 0 ;
36969 int res1 = 0 ;
36970 int val2 ;
36971 int ecode2 = 0 ;
36972 int val3 ;
36973 int ecode3 = 0 ;
36974 int val4 ;
36975 int ecode4 = 0 ;
36976 int val5 ;
36977 int ecode5 = 0 ;
36978 bool val6 ;
36979 int ecode6 = 0 ;
36980 PyObject * obj0 = 0 ;
36981 PyObject * obj1 = 0 ;
36982 PyObject * obj2 = 0 ;
36983 PyObject * obj3 = 0 ;
36984 PyObject * obj4 = 0 ;
36985 PyObject * obj5 = 0 ;
36986 char * kwnames[] = {
36987 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36988 };
36989
36990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36992 if (!SWIG_IsOK(res1)) {
36993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36994 }
36995 arg1 = reinterpret_cast< wxWindow * >(argp1);
36996 ecode2 = SWIG_AsVal_int(obj1, &val2);
36997 if (!SWIG_IsOK(ecode2)) {
36998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36999 }
37000 arg2 = static_cast< int >(val2);
37001 ecode3 = SWIG_AsVal_int(obj2, &val3);
37002 if (!SWIG_IsOK(ecode3)) {
37003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
37004 }
37005 arg3 = static_cast< int >(val3);
37006 ecode4 = SWIG_AsVal_int(obj3, &val4);
37007 if (!SWIG_IsOK(ecode4)) {
37008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
37009 }
37010 arg4 = static_cast< int >(val4);
37011 ecode5 = SWIG_AsVal_int(obj4, &val5);
37012 if (!SWIG_IsOK(ecode5)) {
37013 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
37014 }
37015 arg5 = static_cast< int >(val5);
37016 if (obj5) {
37017 ecode6 = SWIG_AsVal_bool(obj5, &val6);
37018 if (!SWIG_IsOK(ecode6)) {
37019 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
37020 }
37021 arg6 = static_cast< bool >(val6);
37022 }
37023 {
37024 PyThreadState* __tstate = wxPyBeginAllowThreads();
37025 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
37026 wxPyEndAllowThreads(__tstate);
37027 if (PyErr_Occurred()) SWIG_fail;
37028 }
37029 resultobj = SWIG_Py_Void();
37030 return resultobj;
37031 fail:
37032 return NULL;
37033 }
37034
37035
37036 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37037 PyObject *resultobj = 0;
37038 wxWindow *arg1 = (wxWindow *) 0 ;
37039 int arg2 ;
37040 int arg3 ;
37041 bool arg4 = (bool) true ;
37042 void *argp1 = 0 ;
37043 int res1 = 0 ;
37044 int val2 ;
37045 int ecode2 = 0 ;
37046 int val3 ;
37047 int ecode3 = 0 ;
37048 bool val4 ;
37049 int ecode4 = 0 ;
37050 PyObject * obj0 = 0 ;
37051 PyObject * obj1 = 0 ;
37052 PyObject * obj2 = 0 ;
37053 PyObject * obj3 = 0 ;
37054 char * kwnames[] = {
37055 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
37056 };
37057
37058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37060 if (!SWIG_IsOK(res1)) {
37061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
37062 }
37063 arg1 = reinterpret_cast< wxWindow * >(argp1);
37064 ecode2 = SWIG_AsVal_int(obj1, &val2);
37065 if (!SWIG_IsOK(ecode2)) {
37066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
37067 }
37068 arg2 = static_cast< int >(val2);
37069 ecode3 = SWIG_AsVal_int(obj2, &val3);
37070 if (!SWIG_IsOK(ecode3)) {
37071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
37072 }
37073 arg3 = static_cast< int >(val3);
37074 if (obj3) {
37075 ecode4 = SWIG_AsVal_bool(obj3, &val4);
37076 if (!SWIG_IsOK(ecode4)) {
37077 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
37078 }
37079 arg4 = static_cast< bool >(val4);
37080 }
37081 {
37082 PyThreadState* __tstate = wxPyBeginAllowThreads();
37083 (arg1)->SetScrollPos(arg2,arg3,arg4);
37084 wxPyEndAllowThreads(__tstate);
37085 if (PyErr_Occurred()) SWIG_fail;
37086 }
37087 resultobj = SWIG_Py_Void();
37088 return resultobj;
37089 fail:
37090 return NULL;
37091 }
37092
37093
37094 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37095 PyObject *resultobj = 0;
37096 wxWindow *arg1 = (wxWindow *) 0 ;
37097 int arg2 ;
37098 int result;
37099 void *argp1 = 0 ;
37100 int res1 = 0 ;
37101 int val2 ;
37102 int ecode2 = 0 ;
37103 PyObject * obj0 = 0 ;
37104 PyObject * obj1 = 0 ;
37105 char * kwnames[] = {
37106 (char *) "self",(char *) "orientation", NULL
37107 };
37108
37109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
37110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37111 if (!SWIG_IsOK(res1)) {
37112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
37113 }
37114 arg1 = reinterpret_cast< wxWindow * >(argp1);
37115 ecode2 = SWIG_AsVal_int(obj1, &val2);
37116 if (!SWIG_IsOK(ecode2)) {
37117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
37118 }
37119 arg2 = static_cast< int >(val2);
37120 {
37121 PyThreadState* __tstate = wxPyBeginAllowThreads();
37122 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
37123 wxPyEndAllowThreads(__tstate);
37124 if (PyErr_Occurred()) SWIG_fail;
37125 }
37126 resultobj = SWIG_From_int(static_cast< int >(result));
37127 return resultobj;
37128 fail:
37129 return NULL;
37130 }
37131
37132
37133 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37134 PyObject *resultobj = 0;
37135 wxWindow *arg1 = (wxWindow *) 0 ;
37136 int arg2 ;
37137 int result;
37138 void *argp1 = 0 ;
37139 int res1 = 0 ;
37140 int val2 ;
37141 int ecode2 = 0 ;
37142 PyObject * obj0 = 0 ;
37143 PyObject * obj1 = 0 ;
37144 char * kwnames[] = {
37145 (char *) "self",(char *) "orientation", NULL
37146 };
37147
37148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
37149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37150 if (!SWIG_IsOK(res1)) {
37151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
37152 }
37153 arg1 = reinterpret_cast< wxWindow * >(argp1);
37154 ecode2 = SWIG_AsVal_int(obj1, &val2);
37155 if (!SWIG_IsOK(ecode2)) {
37156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
37157 }
37158 arg2 = static_cast< int >(val2);
37159 {
37160 PyThreadState* __tstate = wxPyBeginAllowThreads();
37161 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
37162 wxPyEndAllowThreads(__tstate);
37163 if (PyErr_Occurred()) SWIG_fail;
37164 }
37165 resultobj = SWIG_From_int(static_cast< int >(result));
37166 return resultobj;
37167 fail:
37168 return NULL;
37169 }
37170
37171
37172 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37173 PyObject *resultobj = 0;
37174 wxWindow *arg1 = (wxWindow *) 0 ;
37175 int arg2 ;
37176 int result;
37177 void *argp1 = 0 ;
37178 int res1 = 0 ;
37179 int val2 ;
37180 int ecode2 = 0 ;
37181 PyObject * obj0 = 0 ;
37182 PyObject * obj1 = 0 ;
37183 char * kwnames[] = {
37184 (char *) "self",(char *) "orientation", NULL
37185 };
37186
37187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
37188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37189 if (!SWIG_IsOK(res1)) {
37190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
37191 }
37192 arg1 = reinterpret_cast< wxWindow * >(argp1);
37193 ecode2 = SWIG_AsVal_int(obj1, &val2);
37194 if (!SWIG_IsOK(ecode2)) {
37195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
37196 }
37197 arg2 = static_cast< int >(val2);
37198 {
37199 PyThreadState* __tstate = wxPyBeginAllowThreads();
37200 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
37201 wxPyEndAllowThreads(__tstate);
37202 if (PyErr_Occurred()) SWIG_fail;
37203 }
37204 resultobj = SWIG_From_int(static_cast< int >(result));
37205 return resultobj;
37206 fail:
37207 return NULL;
37208 }
37209
37210
37211 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37212 PyObject *resultobj = 0;
37213 wxWindow *arg1 = (wxWindow *) 0 ;
37214 int arg2 ;
37215 int arg3 ;
37216 wxRect *arg4 = (wxRect *) NULL ;
37217 void *argp1 = 0 ;
37218 int res1 = 0 ;
37219 int val2 ;
37220 int ecode2 = 0 ;
37221 int val3 ;
37222 int ecode3 = 0 ;
37223 void *argp4 = 0 ;
37224 int res4 = 0 ;
37225 PyObject * obj0 = 0 ;
37226 PyObject * obj1 = 0 ;
37227 PyObject * obj2 = 0 ;
37228 PyObject * obj3 = 0 ;
37229 char * kwnames[] = {
37230 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
37231 };
37232
37233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37235 if (!SWIG_IsOK(res1)) {
37236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37237 }
37238 arg1 = reinterpret_cast< wxWindow * >(argp1);
37239 ecode2 = SWIG_AsVal_int(obj1, &val2);
37240 if (!SWIG_IsOK(ecode2)) {
37241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
37242 }
37243 arg2 = static_cast< int >(val2);
37244 ecode3 = SWIG_AsVal_int(obj2, &val3);
37245 if (!SWIG_IsOK(ecode3)) {
37246 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
37247 }
37248 arg3 = static_cast< int >(val3);
37249 if (obj3) {
37250 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
37251 if (!SWIG_IsOK(res4)) {
37252 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
37253 }
37254 arg4 = reinterpret_cast< wxRect * >(argp4);
37255 }
37256 {
37257 PyThreadState* __tstate = wxPyBeginAllowThreads();
37258 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
37259 wxPyEndAllowThreads(__tstate);
37260 if (PyErr_Occurred()) SWIG_fail;
37261 }
37262 resultobj = SWIG_Py_Void();
37263 return resultobj;
37264 fail:
37265 return NULL;
37266 }
37267
37268
37269 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37270 PyObject *resultobj = 0;
37271 wxWindow *arg1 = (wxWindow *) 0 ;
37272 int arg2 ;
37273 bool result;
37274 void *argp1 = 0 ;
37275 int res1 = 0 ;
37276 int val2 ;
37277 int ecode2 = 0 ;
37278 PyObject * obj0 = 0 ;
37279 PyObject * obj1 = 0 ;
37280 char * kwnames[] = {
37281 (char *) "self",(char *) "lines", NULL
37282 };
37283
37284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
37285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37286 if (!SWIG_IsOK(res1)) {
37287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
37288 }
37289 arg1 = reinterpret_cast< wxWindow * >(argp1);
37290 ecode2 = SWIG_AsVal_int(obj1, &val2);
37291 if (!SWIG_IsOK(ecode2)) {
37292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
37293 }
37294 arg2 = static_cast< int >(val2);
37295 {
37296 PyThreadState* __tstate = wxPyBeginAllowThreads();
37297 result = (bool)(arg1)->ScrollLines(arg2);
37298 wxPyEndAllowThreads(__tstate);
37299 if (PyErr_Occurred()) SWIG_fail;
37300 }
37301 {
37302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37303 }
37304 return resultobj;
37305 fail:
37306 return NULL;
37307 }
37308
37309
37310 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37311 PyObject *resultobj = 0;
37312 wxWindow *arg1 = (wxWindow *) 0 ;
37313 int arg2 ;
37314 bool result;
37315 void *argp1 = 0 ;
37316 int res1 = 0 ;
37317 int val2 ;
37318 int ecode2 = 0 ;
37319 PyObject * obj0 = 0 ;
37320 PyObject * obj1 = 0 ;
37321 char * kwnames[] = {
37322 (char *) "self",(char *) "pages", NULL
37323 };
37324
37325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
37326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37327 if (!SWIG_IsOK(res1)) {
37328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
37329 }
37330 arg1 = reinterpret_cast< wxWindow * >(argp1);
37331 ecode2 = SWIG_AsVal_int(obj1, &val2);
37332 if (!SWIG_IsOK(ecode2)) {
37333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
37334 }
37335 arg2 = static_cast< int >(val2);
37336 {
37337 PyThreadState* __tstate = wxPyBeginAllowThreads();
37338 result = (bool)(arg1)->ScrollPages(arg2);
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_LineUp(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_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37364 }
37365 arg1 = reinterpret_cast< wxWindow * >(argp1);
37366 {
37367 PyThreadState* __tstate = wxPyBeginAllowThreads();
37368 result = (bool)(arg1)->LineUp();
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_LineDown(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_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37394 }
37395 arg1 = reinterpret_cast< wxWindow * >(argp1);
37396 {
37397 PyThreadState* __tstate = wxPyBeginAllowThreads();
37398 result = (bool)(arg1)->LineDown();
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_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37412 PyObject *resultobj = 0;
37413 wxWindow *arg1 = (wxWindow *) 0 ;
37414 bool result;
37415 void *argp1 = 0 ;
37416 int res1 = 0 ;
37417 PyObject *swig_obj[1] ;
37418
37419 if (!args) SWIG_fail;
37420 swig_obj[0] = args;
37421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37422 if (!SWIG_IsOK(res1)) {
37423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
37424 }
37425 arg1 = reinterpret_cast< wxWindow * >(argp1);
37426 {
37427 PyThreadState* __tstate = wxPyBeginAllowThreads();
37428 result = (bool)(arg1)->PageUp();
37429 wxPyEndAllowThreads(__tstate);
37430 if (PyErr_Occurred()) SWIG_fail;
37431 }
37432 {
37433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37434 }
37435 return resultobj;
37436 fail:
37437 return NULL;
37438 }
37439
37440
37441 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37442 PyObject *resultobj = 0;
37443 wxWindow *arg1 = (wxWindow *) 0 ;
37444 bool result;
37445 void *argp1 = 0 ;
37446 int res1 = 0 ;
37447 PyObject *swig_obj[1] ;
37448
37449 if (!args) SWIG_fail;
37450 swig_obj[0] = args;
37451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37452 if (!SWIG_IsOK(res1)) {
37453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
37454 }
37455 arg1 = reinterpret_cast< wxWindow * >(argp1);
37456 {
37457 PyThreadState* __tstate = wxPyBeginAllowThreads();
37458 result = (bool)(arg1)->PageDown();
37459 wxPyEndAllowThreads(__tstate);
37460 if (PyErr_Occurred()) SWIG_fail;
37461 }
37462 {
37463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37464 }
37465 return resultobj;
37466 fail:
37467 return NULL;
37468 }
37469
37470
37471 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37472 PyObject *resultobj = 0;
37473 wxWindow *arg1 = (wxWindow *) 0 ;
37474 wxString *arg2 = 0 ;
37475 void *argp1 = 0 ;
37476 int res1 = 0 ;
37477 bool temp2 = false ;
37478 PyObject * obj0 = 0 ;
37479 PyObject * obj1 = 0 ;
37480 char * kwnames[] = {
37481 (char *) "self",(char *) "text", NULL
37482 };
37483
37484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
37485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37486 if (!SWIG_IsOK(res1)) {
37487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
37488 }
37489 arg1 = reinterpret_cast< wxWindow * >(argp1);
37490 {
37491 arg2 = wxString_in_helper(obj1);
37492 if (arg2 == NULL) SWIG_fail;
37493 temp2 = true;
37494 }
37495 {
37496 PyThreadState* __tstate = wxPyBeginAllowThreads();
37497 (arg1)->SetHelpText((wxString const &)*arg2);
37498 wxPyEndAllowThreads(__tstate);
37499 if (PyErr_Occurred()) SWIG_fail;
37500 }
37501 resultobj = SWIG_Py_Void();
37502 {
37503 if (temp2)
37504 delete arg2;
37505 }
37506 return resultobj;
37507 fail:
37508 {
37509 if (temp2)
37510 delete arg2;
37511 }
37512 return NULL;
37513 }
37514
37515
37516 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37517 PyObject *resultobj = 0;
37518 wxWindow *arg1 = (wxWindow *) 0 ;
37519 wxString *arg2 = 0 ;
37520 void *argp1 = 0 ;
37521 int res1 = 0 ;
37522 bool temp2 = false ;
37523 PyObject * obj0 = 0 ;
37524 PyObject * obj1 = 0 ;
37525 char * kwnames[] = {
37526 (char *) "self",(char *) "text", NULL
37527 };
37528
37529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
37530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37531 if (!SWIG_IsOK(res1)) {
37532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
37533 }
37534 arg1 = reinterpret_cast< wxWindow * >(argp1);
37535 {
37536 arg2 = wxString_in_helper(obj1);
37537 if (arg2 == NULL) SWIG_fail;
37538 temp2 = true;
37539 }
37540 {
37541 PyThreadState* __tstate = wxPyBeginAllowThreads();
37542 (arg1)->SetHelpTextForId((wxString const &)*arg2);
37543 wxPyEndAllowThreads(__tstate);
37544 if (PyErr_Occurred()) SWIG_fail;
37545 }
37546 resultobj = SWIG_Py_Void();
37547 {
37548 if (temp2)
37549 delete arg2;
37550 }
37551 return resultobj;
37552 fail:
37553 {
37554 if (temp2)
37555 delete arg2;
37556 }
37557 return NULL;
37558 }
37559
37560
37561 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37562 PyObject *resultobj = 0;
37563 wxWindow *arg1 = (wxWindow *) 0 ;
37564 wxPoint *arg2 = 0 ;
37565 wxHelpEvent::Origin arg3 ;
37566 wxString result;
37567 void *argp1 = 0 ;
37568 int res1 = 0 ;
37569 wxPoint temp2 ;
37570 void *argp3 ;
37571 int res3 = 0 ;
37572 PyObject * obj0 = 0 ;
37573 PyObject * obj1 = 0 ;
37574 PyObject * obj2 = 0 ;
37575 char * kwnames[] = {
37576 (char *) "self",(char *) "pt",(char *) "origin", NULL
37577 };
37578
37579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37581 if (!SWIG_IsOK(res1)) {
37582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37583 }
37584 arg1 = reinterpret_cast< wxWindow * >(argp1);
37585 {
37586 arg2 = &temp2;
37587 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37588 }
37589 {
37590 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37591 if (!SWIG_IsOK(res3)) {
37592 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37593 }
37594 if (!argp3) {
37595 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37596 } else {
37597 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37598 arg3 = *temp;
37599 if (SWIG_IsNewObj(res3)) delete temp;
37600 }
37601 }
37602 {
37603 PyThreadState* __tstate = wxPyBeginAllowThreads();
37604 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37605 wxPyEndAllowThreads(__tstate);
37606 if (PyErr_Occurred()) SWIG_fail;
37607 }
37608 {
37609 #if wxUSE_UNICODE
37610 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37611 #else
37612 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37613 #endif
37614 }
37615 return resultobj;
37616 fail:
37617 return NULL;
37618 }
37619
37620
37621 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37622 PyObject *resultobj = 0;
37623 wxWindow *arg1 = (wxWindow *) 0 ;
37624 wxString result;
37625 void *argp1 = 0 ;
37626 int res1 = 0 ;
37627 PyObject *swig_obj[1] ;
37628
37629 if (!args) SWIG_fail;
37630 swig_obj[0] = args;
37631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37632 if (!SWIG_IsOK(res1)) {
37633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37634 }
37635 arg1 = reinterpret_cast< wxWindow * >(argp1);
37636 {
37637 PyThreadState* __tstate = wxPyBeginAllowThreads();
37638 result = ((wxWindow const *)arg1)->GetHelpText();
37639 wxPyEndAllowThreads(__tstate);
37640 if (PyErr_Occurred()) SWIG_fail;
37641 }
37642 {
37643 #if wxUSE_UNICODE
37644 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37645 #else
37646 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37647 #endif
37648 }
37649 return resultobj;
37650 fail:
37651 return NULL;
37652 }
37653
37654
37655 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37656 PyObject *resultobj = 0;
37657 wxWindow *arg1 = (wxWindow *) 0 ;
37658 wxString *arg2 = 0 ;
37659 void *argp1 = 0 ;
37660 int res1 = 0 ;
37661 bool temp2 = false ;
37662 PyObject * obj0 = 0 ;
37663 PyObject * obj1 = 0 ;
37664 char * kwnames[] = {
37665 (char *) "self",(char *) "tip", NULL
37666 };
37667
37668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37670 if (!SWIG_IsOK(res1)) {
37671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37672 }
37673 arg1 = reinterpret_cast< wxWindow * >(argp1);
37674 {
37675 arg2 = wxString_in_helper(obj1);
37676 if (arg2 == NULL) SWIG_fail;
37677 temp2 = true;
37678 }
37679 {
37680 PyThreadState* __tstate = wxPyBeginAllowThreads();
37681 (arg1)->SetToolTip((wxString const &)*arg2);
37682 wxPyEndAllowThreads(__tstate);
37683 if (PyErr_Occurred()) SWIG_fail;
37684 }
37685 resultobj = SWIG_Py_Void();
37686 {
37687 if (temp2)
37688 delete arg2;
37689 }
37690 return resultobj;
37691 fail:
37692 {
37693 if (temp2)
37694 delete arg2;
37695 }
37696 return NULL;
37697 }
37698
37699
37700 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37701 PyObject *resultobj = 0;
37702 wxWindow *arg1 = (wxWindow *) 0 ;
37703 wxToolTip *arg2 = (wxToolTip *) 0 ;
37704 void *argp1 = 0 ;
37705 int res1 = 0 ;
37706 int res2 = 0 ;
37707 PyObject * obj0 = 0 ;
37708 PyObject * obj1 = 0 ;
37709 char * kwnames[] = {
37710 (char *) "self",(char *) "tip", NULL
37711 };
37712
37713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37715 if (!SWIG_IsOK(res1)) {
37716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37717 }
37718 arg1 = reinterpret_cast< wxWindow * >(argp1);
37719 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37720 if (!SWIG_IsOK(res2)) {
37721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37722 }
37723 {
37724 PyThreadState* __tstate = wxPyBeginAllowThreads();
37725 (arg1)->SetToolTip(arg2);
37726 wxPyEndAllowThreads(__tstate);
37727 if (PyErr_Occurred()) SWIG_fail;
37728 }
37729 resultobj = SWIG_Py_Void();
37730 return resultobj;
37731 fail:
37732 return NULL;
37733 }
37734
37735
37736 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37737 PyObject *resultobj = 0;
37738 wxWindow *arg1 = (wxWindow *) 0 ;
37739 wxToolTip *result = 0 ;
37740 void *argp1 = 0 ;
37741 int res1 = 0 ;
37742 PyObject *swig_obj[1] ;
37743
37744 if (!args) SWIG_fail;
37745 swig_obj[0] = args;
37746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37747 if (!SWIG_IsOK(res1)) {
37748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37749 }
37750 arg1 = reinterpret_cast< wxWindow * >(argp1);
37751 {
37752 PyThreadState* __tstate = wxPyBeginAllowThreads();
37753 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37754 wxPyEndAllowThreads(__tstate);
37755 if (PyErr_Occurred()) SWIG_fail;
37756 }
37757 {
37758 resultobj = wxPyMake_wxObject(result, (bool)0);
37759 }
37760 return resultobj;
37761 fail:
37762 return NULL;
37763 }
37764
37765
37766 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37767 PyObject *resultobj = 0;
37768 wxWindow *arg1 = (wxWindow *) 0 ;
37769 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37770 void *argp1 = 0 ;
37771 int res1 = 0 ;
37772 int res2 = 0 ;
37773 PyObject * obj0 = 0 ;
37774 PyObject * obj1 = 0 ;
37775 char * kwnames[] = {
37776 (char *) "self",(char *) "dropTarget", NULL
37777 };
37778
37779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37781 if (!SWIG_IsOK(res1)) {
37782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37783 }
37784 arg1 = reinterpret_cast< wxWindow * >(argp1);
37785 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37786 if (!SWIG_IsOK(res2)) {
37787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37788 }
37789 {
37790 PyThreadState* __tstate = wxPyBeginAllowThreads();
37791 (arg1)->SetDropTarget(arg2);
37792 wxPyEndAllowThreads(__tstate);
37793 if (PyErr_Occurred()) SWIG_fail;
37794 }
37795 resultobj = SWIG_Py_Void();
37796 return resultobj;
37797 fail:
37798 return NULL;
37799 }
37800
37801
37802 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37803 PyObject *resultobj = 0;
37804 wxWindow *arg1 = (wxWindow *) 0 ;
37805 wxPyDropTarget *result = 0 ;
37806 void *argp1 = 0 ;
37807 int res1 = 0 ;
37808 PyObject *swig_obj[1] ;
37809
37810 if (!args) SWIG_fail;
37811 swig_obj[0] = args;
37812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37813 if (!SWIG_IsOK(res1)) {
37814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37815 }
37816 arg1 = reinterpret_cast< wxWindow * >(argp1);
37817 {
37818 PyThreadState* __tstate = wxPyBeginAllowThreads();
37819 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37820 wxPyEndAllowThreads(__tstate);
37821 if (PyErr_Occurred()) SWIG_fail;
37822 }
37823 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37824 return resultobj;
37825 fail:
37826 return NULL;
37827 }
37828
37829
37830 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37831 PyObject *resultobj = 0;
37832 wxWindow *arg1 = (wxWindow *) 0 ;
37833 bool arg2 ;
37834 void *argp1 = 0 ;
37835 int res1 = 0 ;
37836 bool val2 ;
37837 int ecode2 = 0 ;
37838 PyObject * obj0 = 0 ;
37839 PyObject * obj1 = 0 ;
37840 char * kwnames[] = {
37841 (char *) "self",(char *) "accept", NULL
37842 };
37843
37844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37846 if (!SWIG_IsOK(res1)) {
37847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37848 }
37849 arg1 = reinterpret_cast< wxWindow * >(argp1);
37850 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37851 if (!SWIG_IsOK(ecode2)) {
37852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37853 }
37854 arg2 = static_cast< bool >(val2);
37855 {
37856 PyThreadState* __tstate = wxPyBeginAllowThreads();
37857 wxWindow_DragAcceptFiles(arg1,arg2);
37858 wxPyEndAllowThreads(__tstate);
37859 if (PyErr_Occurred()) SWIG_fail;
37860 }
37861 resultobj = SWIG_Py_Void();
37862 return resultobj;
37863 fail:
37864 return NULL;
37865 }
37866
37867
37868 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37869 PyObject *resultobj = 0;
37870 wxWindow *arg1 = (wxWindow *) 0 ;
37871 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37872 void *argp1 = 0 ;
37873 int res1 = 0 ;
37874 int res2 = 0 ;
37875 PyObject * obj0 = 0 ;
37876 PyObject * obj1 = 0 ;
37877 char * kwnames[] = {
37878 (char *) "self",(char *) "constraints", NULL
37879 };
37880
37881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37883 if (!SWIG_IsOK(res1)) {
37884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37885 }
37886 arg1 = reinterpret_cast< wxWindow * >(argp1);
37887 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37888 if (!SWIG_IsOK(res2)) {
37889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37890 }
37891 {
37892 PyThreadState* __tstate = wxPyBeginAllowThreads();
37893 (arg1)->SetConstraints(arg2);
37894 wxPyEndAllowThreads(__tstate);
37895 if (PyErr_Occurred()) SWIG_fail;
37896 }
37897 resultobj = SWIG_Py_Void();
37898 return resultobj;
37899 fail:
37900 return NULL;
37901 }
37902
37903
37904 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37905 PyObject *resultobj = 0;
37906 wxWindow *arg1 = (wxWindow *) 0 ;
37907 wxLayoutConstraints *result = 0 ;
37908 void *argp1 = 0 ;
37909 int res1 = 0 ;
37910 PyObject *swig_obj[1] ;
37911
37912 if (!args) SWIG_fail;
37913 swig_obj[0] = args;
37914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37915 if (!SWIG_IsOK(res1)) {
37916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37917 }
37918 arg1 = reinterpret_cast< wxWindow * >(argp1);
37919 {
37920 PyThreadState* __tstate = wxPyBeginAllowThreads();
37921 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37922 wxPyEndAllowThreads(__tstate);
37923 if (PyErr_Occurred()) SWIG_fail;
37924 }
37925 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37926 return resultobj;
37927 fail:
37928 return NULL;
37929 }
37930
37931
37932 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37933 PyObject *resultobj = 0;
37934 wxWindow *arg1 = (wxWindow *) 0 ;
37935 bool arg2 ;
37936 void *argp1 = 0 ;
37937 int res1 = 0 ;
37938 bool val2 ;
37939 int ecode2 = 0 ;
37940 PyObject * obj0 = 0 ;
37941 PyObject * obj1 = 0 ;
37942 char * kwnames[] = {
37943 (char *) "self",(char *) "autoLayout", NULL
37944 };
37945
37946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37948 if (!SWIG_IsOK(res1)) {
37949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37950 }
37951 arg1 = reinterpret_cast< wxWindow * >(argp1);
37952 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37953 if (!SWIG_IsOK(ecode2)) {
37954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37955 }
37956 arg2 = static_cast< bool >(val2);
37957 {
37958 PyThreadState* __tstate = wxPyBeginAllowThreads();
37959 (arg1)->SetAutoLayout(arg2);
37960 wxPyEndAllowThreads(__tstate);
37961 if (PyErr_Occurred()) SWIG_fail;
37962 }
37963 resultobj = SWIG_Py_Void();
37964 return resultobj;
37965 fail:
37966 return NULL;
37967 }
37968
37969
37970 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37971 PyObject *resultobj = 0;
37972 wxWindow *arg1 = (wxWindow *) 0 ;
37973 bool result;
37974 void *argp1 = 0 ;
37975 int res1 = 0 ;
37976 PyObject *swig_obj[1] ;
37977
37978 if (!args) SWIG_fail;
37979 swig_obj[0] = args;
37980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37981 if (!SWIG_IsOK(res1)) {
37982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37983 }
37984 arg1 = reinterpret_cast< wxWindow * >(argp1);
37985 {
37986 PyThreadState* __tstate = wxPyBeginAllowThreads();
37987 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37988 wxPyEndAllowThreads(__tstate);
37989 if (PyErr_Occurred()) SWIG_fail;
37990 }
37991 {
37992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37993 }
37994 return resultobj;
37995 fail:
37996 return NULL;
37997 }
37998
37999
38000 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38001 PyObject *resultobj = 0;
38002 wxWindow *arg1 = (wxWindow *) 0 ;
38003 bool result;
38004 void *argp1 = 0 ;
38005 int res1 = 0 ;
38006 PyObject *swig_obj[1] ;
38007
38008 if (!args) SWIG_fail;
38009 swig_obj[0] = args;
38010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38011 if (!SWIG_IsOK(res1)) {
38012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
38013 }
38014 arg1 = reinterpret_cast< wxWindow * >(argp1);
38015 {
38016 PyThreadState* __tstate = wxPyBeginAllowThreads();
38017 result = (bool)(arg1)->Layout();
38018 wxPyEndAllowThreads(__tstate);
38019 if (PyErr_Occurred()) SWIG_fail;
38020 }
38021 {
38022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38023 }
38024 return resultobj;
38025 fail:
38026 return NULL;
38027 }
38028
38029
38030 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38031 PyObject *resultobj = 0;
38032 wxWindow *arg1 = (wxWindow *) 0 ;
38033 wxSizer *arg2 = (wxSizer *) 0 ;
38034 bool arg3 = (bool) true ;
38035 void *argp1 = 0 ;
38036 int res1 = 0 ;
38037 int res2 = 0 ;
38038 bool val3 ;
38039 int ecode3 = 0 ;
38040 PyObject * obj0 = 0 ;
38041 PyObject * obj1 = 0 ;
38042 PyObject * obj2 = 0 ;
38043 char * kwnames[] = {
38044 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38045 };
38046
38047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38049 if (!SWIG_IsOK(res1)) {
38050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38051 }
38052 arg1 = reinterpret_cast< wxWindow * >(argp1);
38053 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38054 if (!SWIG_IsOK(res2)) {
38055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38056 }
38057 if (obj2) {
38058 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38059 if (!SWIG_IsOK(ecode3)) {
38060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
38061 }
38062 arg3 = static_cast< bool >(val3);
38063 }
38064 {
38065 PyThreadState* __tstate = wxPyBeginAllowThreads();
38066 (arg1)->SetSizer(arg2,arg3);
38067 wxPyEndAllowThreads(__tstate);
38068 if (PyErr_Occurred()) SWIG_fail;
38069 }
38070 resultobj = SWIG_Py_Void();
38071 return resultobj;
38072 fail:
38073 return NULL;
38074 }
38075
38076
38077 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38078 PyObject *resultobj = 0;
38079 wxWindow *arg1 = (wxWindow *) 0 ;
38080 wxSizer *arg2 = (wxSizer *) 0 ;
38081 bool arg3 = (bool) true ;
38082 void *argp1 = 0 ;
38083 int res1 = 0 ;
38084 int res2 = 0 ;
38085 bool val3 ;
38086 int ecode3 = 0 ;
38087 PyObject * obj0 = 0 ;
38088 PyObject * obj1 = 0 ;
38089 PyObject * obj2 = 0 ;
38090 char * kwnames[] = {
38091 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
38092 };
38093
38094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38096 if (!SWIG_IsOK(res1)) {
38097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
38098 }
38099 arg1 = reinterpret_cast< wxWindow * >(argp1);
38100 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
38101 if (!SWIG_IsOK(res2)) {
38102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
38103 }
38104 if (obj2) {
38105 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38106 if (!SWIG_IsOK(ecode3)) {
38107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
38108 }
38109 arg3 = static_cast< bool >(val3);
38110 }
38111 {
38112 PyThreadState* __tstate = wxPyBeginAllowThreads();
38113 (arg1)->SetSizerAndFit(arg2,arg3);
38114 wxPyEndAllowThreads(__tstate);
38115 if (PyErr_Occurred()) SWIG_fail;
38116 }
38117 resultobj = SWIG_Py_Void();
38118 return resultobj;
38119 fail:
38120 return NULL;
38121 }
38122
38123
38124 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38125 PyObject *resultobj = 0;
38126 wxWindow *arg1 = (wxWindow *) 0 ;
38127 wxSizer *result = 0 ;
38128 void *argp1 = 0 ;
38129 int res1 = 0 ;
38130 PyObject *swig_obj[1] ;
38131
38132 if (!args) SWIG_fail;
38133 swig_obj[0] = args;
38134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38135 if (!SWIG_IsOK(res1)) {
38136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38137 }
38138 arg1 = reinterpret_cast< wxWindow * >(argp1);
38139 {
38140 PyThreadState* __tstate = wxPyBeginAllowThreads();
38141 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
38142 wxPyEndAllowThreads(__tstate);
38143 if (PyErr_Occurred()) SWIG_fail;
38144 }
38145 {
38146 resultobj = wxPyMake_wxObject(result, (bool)0);
38147 }
38148 return resultobj;
38149 fail:
38150 return NULL;
38151 }
38152
38153
38154 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38155 PyObject *resultobj = 0;
38156 wxWindow *arg1 = (wxWindow *) 0 ;
38157 wxSizer *arg2 = (wxSizer *) 0 ;
38158 void *argp1 = 0 ;
38159 int res1 = 0 ;
38160 void *argp2 = 0 ;
38161 int res2 = 0 ;
38162 PyObject * obj0 = 0 ;
38163 PyObject * obj1 = 0 ;
38164 char * kwnames[] = {
38165 (char *) "self",(char *) "sizer", NULL
38166 };
38167
38168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
38169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38170 if (!SWIG_IsOK(res1)) {
38171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
38172 }
38173 arg1 = reinterpret_cast< wxWindow * >(argp1);
38174 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
38175 if (!SWIG_IsOK(res2)) {
38176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
38177 }
38178 arg2 = reinterpret_cast< wxSizer * >(argp2);
38179 {
38180 PyThreadState* __tstate = wxPyBeginAllowThreads();
38181 (arg1)->SetContainingSizer(arg2);
38182 wxPyEndAllowThreads(__tstate);
38183 if (PyErr_Occurred()) SWIG_fail;
38184 }
38185 resultobj = SWIG_Py_Void();
38186 return resultobj;
38187 fail:
38188 return NULL;
38189 }
38190
38191
38192 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38193 PyObject *resultobj = 0;
38194 wxWindow *arg1 = (wxWindow *) 0 ;
38195 wxSizer *result = 0 ;
38196 void *argp1 = 0 ;
38197 int res1 = 0 ;
38198 PyObject *swig_obj[1] ;
38199
38200 if (!args) SWIG_fail;
38201 swig_obj[0] = args;
38202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38203 if (!SWIG_IsOK(res1)) {
38204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
38205 }
38206 arg1 = reinterpret_cast< wxWindow * >(argp1);
38207 {
38208 PyThreadState* __tstate = wxPyBeginAllowThreads();
38209 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
38210 wxPyEndAllowThreads(__tstate);
38211 if (PyErr_Occurred()) SWIG_fail;
38212 }
38213 {
38214 resultobj = wxPyMake_wxObject(result, (bool)0);
38215 }
38216 return resultobj;
38217 fail:
38218 return NULL;
38219 }
38220
38221
38222 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38223 PyObject *resultobj = 0;
38224 wxWindow *arg1 = (wxWindow *) 0 ;
38225 void *argp1 = 0 ;
38226 int res1 = 0 ;
38227 PyObject *swig_obj[1] ;
38228
38229 if (!args) SWIG_fail;
38230 swig_obj[0] = args;
38231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38232 if (!SWIG_IsOK(res1)) {
38233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
38234 }
38235 arg1 = reinterpret_cast< wxWindow * >(argp1);
38236 {
38237 PyThreadState* __tstate = wxPyBeginAllowThreads();
38238 (arg1)->InheritAttributes();
38239 wxPyEndAllowThreads(__tstate);
38240 if (PyErr_Occurred()) SWIG_fail;
38241 }
38242 resultobj = SWIG_Py_Void();
38243 return resultobj;
38244 fail:
38245 return NULL;
38246 }
38247
38248
38249 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38250 PyObject *resultobj = 0;
38251 wxWindow *arg1 = (wxWindow *) 0 ;
38252 bool result;
38253 void *argp1 = 0 ;
38254 int res1 = 0 ;
38255 PyObject *swig_obj[1] ;
38256
38257 if (!args) SWIG_fail;
38258 swig_obj[0] = args;
38259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38260 if (!SWIG_IsOK(res1)) {
38261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
38262 }
38263 arg1 = reinterpret_cast< wxWindow * >(argp1);
38264 {
38265 PyThreadState* __tstate = wxPyBeginAllowThreads();
38266 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
38267 wxPyEndAllowThreads(__tstate);
38268 if (PyErr_Occurred()) SWIG_fail;
38269 }
38270 {
38271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38272 }
38273 return resultobj;
38274 fail:
38275 return NULL;
38276 }
38277
38278
38279 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38280 PyObject *resultobj = 0;
38281 wxWindow *arg1 = (wxWindow *) 0 ;
38282 bool result;
38283 void *argp1 = 0 ;
38284 int res1 = 0 ;
38285 PyObject *swig_obj[1] ;
38286
38287 if (!args) SWIG_fail;
38288 swig_obj[0] = args;
38289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38290 if (!SWIG_IsOK(res1)) {
38291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38292 }
38293 arg1 = reinterpret_cast< wxWindow * >(argp1);
38294 {
38295 PyThreadState* __tstate = wxPyBeginAllowThreads();
38296 result = (bool)(arg1)->CanSetTransparent();
38297 wxPyEndAllowThreads(__tstate);
38298 if (PyErr_Occurred()) SWIG_fail;
38299 }
38300 {
38301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38302 }
38303 return resultobj;
38304 fail:
38305 return NULL;
38306 }
38307
38308
38309 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38310 PyObject *resultobj = 0;
38311 wxWindow *arg1 = (wxWindow *) 0 ;
38312 byte arg2 ;
38313 bool result;
38314 void *argp1 = 0 ;
38315 int res1 = 0 ;
38316 unsigned char val2 ;
38317 int ecode2 = 0 ;
38318 PyObject * obj0 = 0 ;
38319 PyObject * obj1 = 0 ;
38320 char * kwnames[] = {
38321 (char *) "self",(char *) "alpha", NULL
38322 };
38323
38324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
38325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38326 if (!SWIG_IsOK(res1)) {
38327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
38328 }
38329 arg1 = reinterpret_cast< wxWindow * >(argp1);
38330 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
38331 if (!SWIG_IsOK(ecode2)) {
38332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
38333 }
38334 arg2 = static_cast< byte >(val2);
38335 {
38336 PyThreadState* __tstate = wxPyBeginAllowThreads();
38337 result = (bool)(arg1)->SetTransparent(arg2);
38338 wxPyEndAllowThreads(__tstate);
38339 if (PyErr_Occurred()) SWIG_fail;
38340 }
38341 {
38342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38343 }
38344 return resultobj;
38345 fail:
38346 return NULL;
38347 }
38348
38349
38350 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38351 PyObject *obj;
38352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38353 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
38354 return SWIG_Py_Void();
38355 }
38356
38357 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38358 return SWIG_Python_InitShadowInstance(args);
38359 }
38360
38361 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38362 PyObject *resultobj = 0;
38363 long arg1 ;
38364 wxWindow *arg2 = (wxWindow *) NULL ;
38365 wxWindow *result = 0 ;
38366 long val1 ;
38367 int ecode1 = 0 ;
38368 void *argp2 = 0 ;
38369 int res2 = 0 ;
38370 PyObject * obj0 = 0 ;
38371 PyObject * obj1 = 0 ;
38372 char * kwnames[] = {
38373 (char *) "id",(char *) "parent", NULL
38374 };
38375
38376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
38377 ecode1 = SWIG_AsVal_long(obj0, &val1);
38378 if (!SWIG_IsOK(ecode1)) {
38379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
38380 }
38381 arg1 = static_cast< long >(val1);
38382 if (obj1) {
38383 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38384 if (!SWIG_IsOK(res2)) {
38385 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
38386 }
38387 arg2 = reinterpret_cast< wxWindow * >(argp2);
38388 }
38389 {
38390 if (!wxPyCheckForApp()) SWIG_fail;
38391 PyThreadState* __tstate = wxPyBeginAllowThreads();
38392 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
38393 wxPyEndAllowThreads(__tstate);
38394 if (PyErr_Occurred()) SWIG_fail;
38395 }
38396 {
38397 resultobj = wxPyMake_wxObject(result, 0);
38398 }
38399 return resultobj;
38400 fail:
38401 return NULL;
38402 }
38403
38404
38405 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38406 PyObject *resultobj = 0;
38407 wxString *arg1 = 0 ;
38408 wxWindow *arg2 = (wxWindow *) NULL ;
38409 wxWindow *result = 0 ;
38410 bool temp1 = false ;
38411 void *argp2 = 0 ;
38412 int res2 = 0 ;
38413 PyObject * obj0 = 0 ;
38414 PyObject * obj1 = 0 ;
38415 char * kwnames[] = {
38416 (char *) "name",(char *) "parent", NULL
38417 };
38418
38419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
38420 {
38421 arg1 = wxString_in_helper(obj0);
38422 if (arg1 == NULL) SWIG_fail;
38423 temp1 = true;
38424 }
38425 if (obj1) {
38426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38427 if (!SWIG_IsOK(res2)) {
38428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
38429 }
38430 arg2 = reinterpret_cast< wxWindow * >(argp2);
38431 }
38432 {
38433 if (!wxPyCheckForApp()) SWIG_fail;
38434 PyThreadState* __tstate = wxPyBeginAllowThreads();
38435 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
38436 wxPyEndAllowThreads(__tstate);
38437 if (PyErr_Occurred()) SWIG_fail;
38438 }
38439 {
38440 resultobj = wxPyMake_wxObject(result, 0);
38441 }
38442 {
38443 if (temp1)
38444 delete arg1;
38445 }
38446 return resultobj;
38447 fail:
38448 {
38449 if (temp1)
38450 delete arg1;
38451 }
38452 return NULL;
38453 }
38454
38455
38456 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38457 PyObject *resultobj = 0;
38458 wxString *arg1 = 0 ;
38459 wxWindow *arg2 = (wxWindow *) NULL ;
38460 wxWindow *result = 0 ;
38461 bool temp1 = false ;
38462 void *argp2 = 0 ;
38463 int res2 = 0 ;
38464 PyObject * obj0 = 0 ;
38465 PyObject * obj1 = 0 ;
38466 char * kwnames[] = {
38467 (char *) "label",(char *) "parent", NULL
38468 };
38469
38470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
38471 {
38472 arg1 = wxString_in_helper(obj0);
38473 if (arg1 == NULL) SWIG_fail;
38474 temp1 = true;
38475 }
38476 if (obj1) {
38477 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38478 if (!SWIG_IsOK(res2)) {
38479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
38480 }
38481 arg2 = reinterpret_cast< wxWindow * >(argp2);
38482 }
38483 {
38484 if (!wxPyCheckForApp()) SWIG_fail;
38485 PyThreadState* __tstate = wxPyBeginAllowThreads();
38486 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
38487 wxPyEndAllowThreads(__tstate);
38488 if (PyErr_Occurred()) SWIG_fail;
38489 }
38490 {
38491 resultobj = wxPyMake_wxObject(result, 0);
38492 }
38493 {
38494 if (temp1)
38495 delete arg1;
38496 }
38497 return resultobj;
38498 fail:
38499 {
38500 if (temp1)
38501 delete arg1;
38502 }
38503 return NULL;
38504 }
38505
38506
38507 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38508 PyObject *resultobj = 0;
38509 wxWindow *arg1 = (wxWindow *) 0 ;
38510 unsigned long arg2 ;
38511 wxWindow *result = 0 ;
38512 void *argp1 = 0 ;
38513 int res1 = 0 ;
38514 unsigned long val2 ;
38515 int ecode2 = 0 ;
38516 PyObject * obj0 = 0 ;
38517 PyObject * obj1 = 0 ;
38518 char * kwnames[] = {
38519 (char *) "parent",(char *) "_hWnd", NULL
38520 };
38521
38522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
38523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38524 if (!SWIG_IsOK(res1)) {
38525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
38526 }
38527 arg1 = reinterpret_cast< wxWindow * >(argp1);
38528 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
38529 if (!SWIG_IsOK(ecode2)) {
38530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
38531 }
38532 arg2 = static_cast< unsigned long >(val2);
38533 {
38534 PyThreadState* __tstate = wxPyBeginAllowThreads();
38535 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
38536 wxPyEndAllowThreads(__tstate);
38537 if (PyErr_Occurred()) SWIG_fail;
38538 }
38539 {
38540 resultobj = wxPyMake_wxObject(result, 0);
38541 }
38542 return resultobj;
38543 fail:
38544 return NULL;
38545 }
38546
38547
38548 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38549 PyObject *resultobj = 0;
38550 PyObject *result = 0 ;
38551
38552 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
38553 {
38554 PyThreadState* __tstate = wxPyBeginAllowThreads();
38555 result = (PyObject *)GetTopLevelWindows();
38556 wxPyEndAllowThreads(__tstate);
38557 if (PyErr_Occurred()) SWIG_fail;
38558 }
38559 resultobj = result;
38560 return resultobj;
38561 fail:
38562 return NULL;
38563 }
38564
38565
38566 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38567 PyObject *resultobj = 0;
38568 wxValidator *result = 0 ;
38569
38570 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
38571 {
38572 PyThreadState* __tstate = wxPyBeginAllowThreads();
38573 result = (wxValidator *)new wxValidator();
38574 wxPyEndAllowThreads(__tstate);
38575 if (PyErr_Occurred()) SWIG_fail;
38576 }
38577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
38578 return resultobj;
38579 fail:
38580 return NULL;
38581 }
38582
38583
38584 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38585 PyObject *resultobj = 0;
38586 wxValidator *arg1 = (wxValidator *) 0 ;
38587 wxValidator *result = 0 ;
38588 void *argp1 = 0 ;
38589 int res1 = 0 ;
38590 PyObject *swig_obj[1] ;
38591
38592 if (!args) SWIG_fail;
38593 swig_obj[0] = args;
38594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38595 if (!SWIG_IsOK(res1)) {
38596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
38597 }
38598 arg1 = reinterpret_cast< wxValidator * >(argp1);
38599 {
38600 PyThreadState* __tstate = wxPyBeginAllowThreads();
38601 result = (wxValidator *)(arg1)->Clone();
38602 wxPyEndAllowThreads(__tstate);
38603 if (PyErr_Occurred()) SWIG_fail;
38604 }
38605 {
38606 resultobj = wxPyMake_wxObject(result, 0);
38607 }
38608 return resultobj;
38609 fail:
38610 return NULL;
38611 }
38612
38613
38614 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38615 PyObject *resultobj = 0;
38616 wxValidator *arg1 = (wxValidator *) 0 ;
38617 wxWindow *arg2 = (wxWindow *) 0 ;
38618 bool result;
38619 void *argp1 = 0 ;
38620 int res1 = 0 ;
38621 void *argp2 = 0 ;
38622 int res2 = 0 ;
38623 PyObject * obj0 = 0 ;
38624 PyObject * obj1 = 0 ;
38625 char * kwnames[] = {
38626 (char *) "self",(char *) "parent", NULL
38627 };
38628
38629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
38630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38631 if (!SWIG_IsOK(res1)) {
38632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
38633 }
38634 arg1 = reinterpret_cast< wxValidator * >(argp1);
38635 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38636 if (!SWIG_IsOK(res2)) {
38637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
38638 }
38639 arg2 = reinterpret_cast< wxWindow * >(argp2);
38640 {
38641 PyThreadState* __tstate = wxPyBeginAllowThreads();
38642 result = (bool)(arg1)->Validate(arg2);
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_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38656 PyObject *resultobj = 0;
38657 wxValidator *arg1 = (wxValidator *) 0 ;
38658 bool result;
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_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38668 }
38669 arg1 = reinterpret_cast< wxValidator * >(argp1);
38670 {
38671 PyThreadState* __tstate = wxPyBeginAllowThreads();
38672 result = (bool)(arg1)->TransferToWindow();
38673 wxPyEndAllowThreads(__tstate);
38674 if (PyErr_Occurred()) SWIG_fail;
38675 }
38676 {
38677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38678 }
38679 return resultobj;
38680 fail:
38681 return NULL;
38682 }
38683
38684
38685 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38686 PyObject *resultobj = 0;
38687 wxValidator *arg1 = (wxValidator *) 0 ;
38688 bool result;
38689 void *argp1 = 0 ;
38690 int res1 = 0 ;
38691 PyObject *swig_obj[1] ;
38692
38693 if (!args) SWIG_fail;
38694 swig_obj[0] = args;
38695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38696 if (!SWIG_IsOK(res1)) {
38697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38698 }
38699 arg1 = reinterpret_cast< wxValidator * >(argp1);
38700 {
38701 PyThreadState* __tstate = wxPyBeginAllowThreads();
38702 result = (bool)(arg1)->TransferFromWindow();
38703 wxPyEndAllowThreads(__tstate);
38704 if (PyErr_Occurred()) SWIG_fail;
38705 }
38706 {
38707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38708 }
38709 return resultobj;
38710 fail:
38711 return NULL;
38712 }
38713
38714
38715 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38716 PyObject *resultobj = 0;
38717 wxValidator *arg1 = (wxValidator *) 0 ;
38718 wxWindow *result = 0 ;
38719 void *argp1 = 0 ;
38720 int res1 = 0 ;
38721 PyObject *swig_obj[1] ;
38722
38723 if (!args) SWIG_fail;
38724 swig_obj[0] = args;
38725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38726 if (!SWIG_IsOK(res1)) {
38727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38728 }
38729 arg1 = reinterpret_cast< wxValidator * >(argp1);
38730 {
38731 PyThreadState* __tstate = wxPyBeginAllowThreads();
38732 result = (wxWindow *)(arg1)->GetWindow();
38733 wxPyEndAllowThreads(__tstate);
38734 if (PyErr_Occurred()) SWIG_fail;
38735 }
38736 {
38737 resultobj = wxPyMake_wxObject(result, 0);
38738 }
38739 return resultobj;
38740 fail:
38741 return NULL;
38742 }
38743
38744
38745 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38746 PyObject *resultobj = 0;
38747 wxValidator *arg1 = (wxValidator *) 0 ;
38748 wxWindow *arg2 = (wxWindow *) 0 ;
38749 void *argp1 = 0 ;
38750 int res1 = 0 ;
38751 void *argp2 = 0 ;
38752 int res2 = 0 ;
38753 PyObject * obj0 = 0 ;
38754 PyObject * obj1 = 0 ;
38755 char * kwnames[] = {
38756 (char *) "self",(char *) "window", NULL
38757 };
38758
38759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38761 if (!SWIG_IsOK(res1)) {
38762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38763 }
38764 arg1 = reinterpret_cast< wxValidator * >(argp1);
38765 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38766 if (!SWIG_IsOK(res2)) {
38767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38768 }
38769 arg2 = reinterpret_cast< wxWindow * >(argp2);
38770 {
38771 PyThreadState* __tstate = wxPyBeginAllowThreads();
38772 (arg1)->SetWindow(arg2);
38773 wxPyEndAllowThreads(__tstate);
38774 if (PyErr_Occurred()) SWIG_fail;
38775 }
38776 resultobj = SWIG_Py_Void();
38777 return resultobj;
38778 fail:
38779 return NULL;
38780 }
38781
38782
38783 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38784 PyObject *resultobj = 0;
38785 bool result;
38786
38787 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38788 {
38789 PyThreadState* __tstate = wxPyBeginAllowThreads();
38790 result = (bool)wxValidator::IsSilent();
38791 wxPyEndAllowThreads(__tstate);
38792 if (PyErr_Occurred()) SWIG_fail;
38793 }
38794 {
38795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38796 }
38797 return resultobj;
38798 fail:
38799 return NULL;
38800 }
38801
38802
38803 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38804 PyObject *resultobj = 0;
38805 int arg1 = (int) true ;
38806 int val1 ;
38807 int ecode1 = 0 ;
38808 PyObject * obj0 = 0 ;
38809 char * kwnames[] = {
38810 (char *) "doIt", NULL
38811 };
38812
38813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38814 if (obj0) {
38815 ecode1 = SWIG_AsVal_int(obj0, &val1);
38816 if (!SWIG_IsOK(ecode1)) {
38817 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38818 }
38819 arg1 = static_cast< int >(val1);
38820 }
38821 {
38822 PyThreadState* __tstate = wxPyBeginAllowThreads();
38823 wxValidator::SetBellOnError(arg1);
38824 wxPyEndAllowThreads(__tstate);
38825 if (PyErr_Occurred()) SWIG_fail;
38826 }
38827 resultobj = SWIG_Py_Void();
38828 return resultobj;
38829 fail:
38830 return NULL;
38831 }
38832
38833
38834 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38835 PyObject *obj;
38836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38837 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38838 return SWIG_Py_Void();
38839 }
38840
38841 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38842 return SWIG_Python_InitShadowInstance(args);
38843 }
38844
38845 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38846 PyObject *resultobj = 0;
38847 wxPyValidator *result = 0 ;
38848
38849 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38850 {
38851 PyThreadState* __tstate = wxPyBeginAllowThreads();
38852 result = (wxPyValidator *)new wxPyValidator();
38853 wxPyEndAllowThreads(__tstate);
38854 if (PyErr_Occurred()) SWIG_fail;
38855 }
38856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38857 return resultobj;
38858 fail:
38859 return NULL;
38860 }
38861
38862
38863 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38864 PyObject *resultobj = 0;
38865 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38866 PyObject *arg2 = (PyObject *) 0 ;
38867 PyObject *arg3 = (PyObject *) 0 ;
38868 int arg4 = (int) true ;
38869 void *argp1 = 0 ;
38870 int res1 = 0 ;
38871 int val4 ;
38872 int ecode4 = 0 ;
38873 PyObject * obj0 = 0 ;
38874 PyObject * obj1 = 0 ;
38875 PyObject * obj2 = 0 ;
38876 PyObject * obj3 = 0 ;
38877 char * kwnames[] = {
38878 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38879 };
38880
38881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38883 if (!SWIG_IsOK(res1)) {
38884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38885 }
38886 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38887 arg2 = obj1;
38888 arg3 = obj2;
38889 if (obj3) {
38890 ecode4 = SWIG_AsVal_int(obj3, &val4);
38891 if (!SWIG_IsOK(ecode4)) {
38892 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38893 }
38894 arg4 = static_cast< int >(val4);
38895 }
38896 {
38897 PyThreadState* __tstate = wxPyBeginAllowThreads();
38898 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38899 wxPyEndAllowThreads(__tstate);
38900 if (PyErr_Occurred()) SWIG_fail;
38901 }
38902 resultobj = SWIG_Py_Void();
38903 return resultobj;
38904 fail:
38905 return NULL;
38906 }
38907
38908
38909 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38910 PyObject *obj;
38911 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38912 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38913 return SWIG_Py_Void();
38914 }
38915
38916 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38917 return SWIG_Python_InitShadowInstance(args);
38918 }
38919
38920 SWIGINTERN int DefaultValidator_set(PyObject *) {
38921 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38922 return 1;
38923 }
38924
38925
38926 SWIGINTERN PyObject *DefaultValidator_get(void) {
38927 PyObject *pyobj = 0;
38928
38929 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38930 return pyobj;
38931 }
38932
38933
38934 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38935 PyObject *resultobj = 0;
38936 wxString const &arg1_defvalue = wxPyEmptyString ;
38937 wxString *arg1 = (wxString *) &arg1_defvalue ;
38938 long arg2 = (long) 0 ;
38939 wxMenu *result = 0 ;
38940 bool temp1 = false ;
38941 long val2 ;
38942 int ecode2 = 0 ;
38943 PyObject * obj0 = 0 ;
38944 PyObject * obj1 = 0 ;
38945 char * kwnames[] = {
38946 (char *) "title",(char *) "style", NULL
38947 };
38948
38949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38950 if (obj0) {
38951 {
38952 arg1 = wxString_in_helper(obj0);
38953 if (arg1 == NULL) SWIG_fail;
38954 temp1 = true;
38955 }
38956 }
38957 if (obj1) {
38958 ecode2 = SWIG_AsVal_long(obj1, &val2);
38959 if (!SWIG_IsOK(ecode2)) {
38960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38961 }
38962 arg2 = static_cast< long >(val2);
38963 }
38964 {
38965 if (!wxPyCheckForApp()) SWIG_fail;
38966 PyThreadState* __tstate = wxPyBeginAllowThreads();
38967 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38968 wxPyEndAllowThreads(__tstate);
38969 if (PyErr_Occurred()) SWIG_fail;
38970 }
38971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38972 {
38973 if (temp1)
38974 delete arg1;
38975 }
38976 return resultobj;
38977 fail:
38978 {
38979 if (temp1)
38980 delete arg1;
38981 }
38982 return NULL;
38983 }
38984
38985
38986 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38987 PyObject *resultobj = 0;
38988 wxMenu *arg1 = (wxMenu *) 0 ;
38989 int arg2 ;
38990 wxString const &arg3_defvalue = wxPyEmptyString ;
38991 wxString *arg3 = (wxString *) &arg3_defvalue ;
38992 wxString const &arg4_defvalue = wxPyEmptyString ;
38993 wxString *arg4 = (wxString *) &arg4_defvalue ;
38994 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38995 wxMenuItem *result = 0 ;
38996 void *argp1 = 0 ;
38997 int res1 = 0 ;
38998 int val2 ;
38999 int ecode2 = 0 ;
39000 bool temp3 = false ;
39001 bool temp4 = false ;
39002 int val5 ;
39003 int ecode5 = 0 ;
39004 PyObject * obj0 = 0 ;
39005 PyObject * obj1 = 0 ;
39006 PyObject * obj2 = 0 ;
39007 PyObject * obj3 = 0 ;
39008 PyObject * obj4 = 0 ;
39009 char * kwnames[] = {
39010 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39011 };
39012
39013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39015 if (!SWIG_IsOK(res1)) {
39016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
39017 }
39018 arg1 = reinterpret_cast< wxMenu * >(argp1);
39019 ecode2 = SWIG_AsVal_int(obj1, &val2);
39020 if (!SWIG_IsOK(ecode2)) {
39021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
39022 }
39023 arg2 = static_cast< int >(val2);
39024 if (obj2) {
39025 {
39026 arg3 = wxString_in_helper(obj2);
39027 if (arg3 == NULL) SWIG_fail;
39028 temp3 = true;
39029 }
39030 }
39031 if (obj3) {
39032 {
39033 arg4 = wxString_in_helper(obj3);
39034 if (arg4 == NULL) SWIG_fail;
39035 temp4 = true;
39036 }
39037 }
39038 if (obj4) {
39039 ecode5 = SWIG_AsVal_int(obj4, &val5);
39040 if (!SWIG_IsOK(ecode5)) {
39041 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
39042 }
39043 arg5 = static_cast< wxItemKind >(val5);
39044 }
39045 {
39046 PyThreadState* __tstate = wxPyBeginAllowThreads();
39047 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39048 wxPyEndAllowThreads(__tstate);
39049 if (PyErr_Occurred()) SWIG_fail;
39050 }
39051 {
39052 resultobj = wxPyMake_wxObject(result, (bool)0);
39053 }
39054 {
39055 if (temp3)
39056 delete arg3;
39057 }
39058 {
39059 if (temp4)
39060 delete arg4;
39061 }
39062 return resultobj;
39063 fail:
39064 {
39065 if (temp3)
39066 delete arg3;
39067 }
39068 {
39069 if (temp4)
39070 delete arg4;
39071 }
39072 return NULL;
39073 }
39074
39075
39076 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39077 PyObject *resultobj = 0;
39078 wxMenu *arg1 = (wxMenu *) 0 ;
39079 wxMenuItem *result = 0 ;
39080 void *argp1 = 0 ;
39081 int res1 = 0 ;
39082 PyObject *swig_obj[1] ;
39083
39084 if (!args) SWIG_fail;
39085 swig_obj[0] = args;
39086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39087 if (!SWIG_IsOK(res1)) {
39088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39089 }
39090 arg1 = reinterpret_cast< wxMenu * >(argp1);
39091 {
39092 PyThreadState* __tstate = wxPyBeginAllowThreads();
39093 result = (wxMenuItem *)(arg1)->AppendSeparator();
39094 wxPyEndAllowThreads(__tstate);
39095 if (PyErr_Occurred()) SWIG_fail;
39096 }
39097 {
39098 resultobj = wxPyMake_wxObject(result, (bool)0);
39099 }
39100 return resultobj;
39101 fail:
39102 return NULL;
39103 }
39104
39105
39106 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39107 PyObject *resultobj = 0;
39108 wxMenu *arg1 = (wxMenu *) 0 ;
39109 int arg2 ;
39110 wxString *arg3 = 0 ;
39111 wxString const &arg4_defvalue = wxPyEmptyString ;
39112 wxString *arg4 = (wxString *) &arg4_defvalue ;
39113 wxMenuItem *result = 0 ;
39114 void *argp1 = 0 ;
39115 int res1 = 0 ;
39116 int val2 ;
39117 int ecode2 = 0 ;
39118 bool temp3 = false ;
39119 bool temp4 = false ;
39120 PyObject * obj0 = 0 ;
39121 PyObject * obj1 = 0 ;
39122 PyObject * obj2 = 0 ;
39123 PyObject * obj3 = 0 ;
39124 char * kwnames[] = {
39125 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39126 };
39127
39128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39130 if (!SWIG_IsOK(res1)) {
39131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39132 }
39133 arg1 = reinterpret_cast< wxMenu * >(argp1);
39134 ecode2 = SWIG_AsVal_int(obj1, &val2);
39135 if (!SWIG_IsOK(ecode2)) {
39136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
39137 }
39138 arg2 = static_cast< int >(val2);
39139 {
39140 arg3 = wxString_in_helper(obj2);
39141 if (arg3 == NULL) SWIG_fail;
39142 temp3 = true;
39143 }
39144 if (obj3) {
39145 {
39146 arg4 = wxString_in_helper(obj3);
39147 if (arg4 == NULL) SWIG_fail;
39148 temp4 = true;
39149 }
39150 }
39151 {
39152 PyThreadState* __tstate = wxPyBeginAllowThreads();
39153 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39154 wxPyEndAllowThreads(__tstate);
39155 if (PyErr_Occurred()) SWIG_fail;
39156 }
39157 {
39158 resultobj = wxPyMake_wxObject(result, (bool)0);
39159 }
39160 {
39161 if (temp3)
39162 delete arg3;
39163 }
39164 {
39165 if (temp4)
39166 delete arg4;
39167 }
39168 return resultobj;
39169 fail:
39170 {
39171 if (temp3)
39172 delete arg3;
39173 }
39174 {
39175 if (temp4)
39176 delete arg4;
39177 }
39178 return NULL;
39179 }
39180
39181
39182 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39183 PyObject *resultobj = 0;
39184 wxMenu *arg1 = (wxMenu *) 0 ;
39185 int arg2 ;
39186 wxString *arg3 = 0 ;
39187 wxString const &arg4_defvalue = wxPyEmptyString ;
39188 wxString *arg4 = (wxString *) &arg4_defvalue ;
39189 wxMenuItem *result = 0 ;
39190 void *argp1 = 0 ;
39191 int res1 = 0 ;
39192 int val2 ;
39193 int ecode2 = 0 ;
39194 bool temp3 = false ;
39195 bool temp4 = false ;
39196 PyObject * obj0 = 0 ;
39197 PyObject * obj1 = 0 ;
39198 PyObject * obj2 = 0 ;
39199 PyObject * obj3 = 0 ;
39200 char * kwnames[] = {
39201 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39202 };
39203
39204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39206 if (!SWIG_IsOK(res1)) {
39207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39208 }
39209 arg1 = reinterpret_cast< wxMenu * >(argp1);
39210 ecode2 = SWIG_AsVal_int(obj1, &val2);
39211 if (!SWIG_IsOK(ecode2)) {
39212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
39213 }
39214 arg2 = static_cast< int >(val2);
39215 {
39216 arg3 = wxString_in_helper(obj2);
39217 if (arg3 == NULL) SWIG_fail;
39218 temp3 = true;
39219 }
39220 if (obj3) {
39221 {
39222 arg4 = wxString_in_helper(obj3);
39223 if (arg4 == NULL) SWIG_fail;
39224 temp4 = true;
39225 }
39226 }
39227 {
39228 PyThreadState* __tstate = wxPyBeginAllowThreads();
39229 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39230 wxPyEndAllowThreads(__tstate);
39231 if (PyErr_Occurred()) SWIG_fail;
39232 }
39233 {
39234 resultobj = wxPyMake_wxObject(result, (bool)0);
39235 }
39236 {
39237 if (temp3)
39238 delete arg3;
39239 }
39240 {
39241 if (temp4)
39242 delete arg4;
39243 }
39244 return resultobj;
39245 fail:
39246 {
39247 if (temp3)
39248 delete arg3;
39249 }
39250 {
39251 if (temp4)
39252 delete arg4;
39253 }
39254 return NULL;
39255 }
39256
39257
39258 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39259 PyObject *resultobj = 0;
39260 wxMenu *arg1 = (wxMenu *) 0 ;
39261 int arg2 ;
39262 wxString *arg3 = 0 ;
39263 wxMenu *arg4 = (wxMenu *) 0 ;
39264 wxString const &arg5_defvalue = wxPyEmptyString ;
39265 wxString *arg5 = (wxString *) &arg5_defvalue ;
39266 wxMenuItem *result = 0 ;
39267 void *argp1 = 0 ;
39268 int res1 = 0 ;
39269 int val2 ;
39270 int ecode2 = 0 ;
39271 bool temp3 = false ;
39272 void *argp4 = 0 ;
39273 int res4 = 0 ;
39274 bool temp5 = false ;
39275 PyObject * obj0 = 0 ;
39276 PyObject * obj1 = 0 ;
39277 PyObject * obj2 = 0 ;
39278 PyObject * obj3 = 0 ;
39279 PyObject * obj4 = 0 ;
39280 char * kwnames[] = {
39281 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39282 };
39283
39284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39285 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39286 if (!SWIG_IsOK(res1)) {
39287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39288 }
39289 arg1 = reinterpret_cast< wxMenu * >(argp1);
39290 ecode2 = SWIG_AsVal_int(obj1, &val2);
39291 if (!SWIG_IsOK(ecode2)) {
39292 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
39293 }
39294 arg2 = static_cast< int >(val2);
39295 {
39296 arg3 = wxString_in_helper(obj2);
39297 if (arg3 == NULL) SWIG_fail;
39298 temp3 = true;
39299 }
39300 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39301 if (!SWIG_IsOK(res4)) {
39302 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39303 }
39304 arg4 = reinterpret_cast< wxMenu * >(argp4);
39305 if (obj4) {
39306 {
39307 arg5 = wxString_in_helper(obj4);
39308 if (arg5 == NULL) SWIG_fail;
39309 temp5 = true;
39310 }
39311 }
39312 {
39313 PyThreadState* __tstate = wxPyBeginAllowThreads();
39314 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39315 wxPyEndAllowThreads(__tstate);
39316 if (PyErr_Occurred()) SWIG_fail;
39317 }
39318 {
39319 resultobj = wxPyMake_wxObject(result, (bool)0);
39320 }
39321 {
39322 if (temp3)
39323 delete arg3;
39324 }
39325 {
39326 if (temp5)
39327 delete arg5;
39328 }
39329 return resultobj;
39330 fail:
39331 {
39332 if (temp3)
39333 delete arg3;
39334 }
39335 {
39336 if (temp5)
39337 delete arg5;
39338 }
39339 return NULL;
39340 }
39341
39342
39343 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39344 PyObject *resultobj = 0;
39345 wxMenu *arg1 = (wxMenu *) 0 ;
39346 wxMenu *arg2 = (wxMenu *) 0 ;
39347 wxString *arg3 = 0 ;
39348 wxString const &arg4_defvalue = wxPyEmptyString ;
39349 wxString *arg4 = (wxString *) &arg4_defvalue ;
39350 wxMenuItem *result = 0 ;
39351 void *argp1 = 0 ;
39352 int res1 = 0 ;
39353 void *argp2 = 0 ;
39354 int res2 = 0 ;
39355 bool temp3 = false ;
39356 bool temp4 = false ;
39357 PyObject * obj0 = 0 ;
39358 PyObject * obj1 = 0 ;
39359 PyObject * obj2 = 0 ;
39360 PyObject * obj3 = 0 ;
39361 char * kwnames[] = {
39362 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
39363 };
39364
39365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39367 if (!SWIG_IsOK(res1)) {
39368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39369 }
39370 arg1 = reinterpret_cast< wxMenu * >(argp1);
39371 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39372 if (!SWIG_IsOK(res2)) {
39373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39374 }
39375 arg2 = reinterpret_cast< wxMenu * >(argp2);
39376 {
39377 arg3 = wxString_in_helper(obj2);
39378 if (arg3 == NULL) SWIG_fail;
39379 temp3 = true;
39380 }
39381 if (obj3) {
39382 {
39383 arg4 = wxString_in_helper(obj3);
39384 if (arg4 == NULL) SWIG_fail;
39385 temp4 = true;
39386 }
39387 }
39388 {
39389 PyThreadState* __tstate = wxPyBeginAllowThreads();
39390 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39391 wxPyEndAllowThreads(__tstate);
39392 if (PyErr_Occurred()) SWIG_fail;
39393 }
39394 {
39395 resultobj = wxPyMake_wxObject(result, (bool)0);
39396 }
39397 {
39398 if (temp3)
39399 delete arg3;
39400 }
39401 {
39402 if (temp4)
39403 delete arg4;
39404 }
39405 return resultobj;
39406 fail:
39407 {
39408 if (temp3)
39409 delete arg3;
39410 }
39411 {
39412 if (temp4)
39413 delete arg4;
39414 }
39415 return NULL;
39416 }
39417
39418
39419 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39420 PyObject *resultobj = 0;
39421 wxMenu *arg1 = (wxMenu *) 0 ;
39422 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39423 wxMenuItem *result = 0 ;
39424 void *argp1 = 0 ;
39425 int res1 = 0 ;
39426 int res2 = 0 ;
39427 PyObject * obj0 = 0 ;
39428 PyObject * obj1 = 0 ;
39429 char * kwnames[] = {
39430 (char *) "self",(char *) "item", NULL
39431 };
39432
39433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
39434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39435 if (!SWIG_IsOK(res1)) {
39436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39437 }
39438 arg1 = reinterpret_cast< wxMenu * >(argp1);
39439 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39440 if (!SWIG_IsOK(res2)) {
39441 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39442 }
39443 {
39444 PyThreadState* __tstate = wxPyBeginAllowThreads();
39445 result = (wxMenuItem *)(arg1)->Append(arg2);
39446 wxPyEndAllowThreads(__tstate);
39447 if (PyErr_Occurred()) SWIG_fail;
39448 }
39449 {
39450 resultobj = wxPyMake_wxObject(result, (bool)0);
39451 }
39452 return resultobj;
39453 fail:
39454 return NULL;
39455 }
39456
39457
39458 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39459 PyObject *resultobj = 0;
39460 wxMenu *arg1 = (wxMenu *) 0 ;
39461 size_t arg2 ;
39462 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
39463 wxMenuItem *result = 0 ;
39464 void *argp1 = 0 ;
39465 int res1 = 0 ;
39466 size_t val2 ;
39467 int ecode2 = 0 ;
39468 int res3 = 0 ;
39469 PyObject * obj0 = 0 ;
39470 PyObject * obj1 = 0 ;
39471 PyObject * obj2 = 0 ;
39472 char * kwnames[] = {
39473 (char *) "self",(char *) "pos",(char *) "item", NULL
39474 };
39475
39476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39478 if (!SWIG_IsOK(res1)) {
39479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39480 }
39481 arg1 = reinterpret_cast< wxMenu * >(argp1);
39482 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39483 if (!SWIG_IsOK(ecode2)) {
39484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
39485 }
39486 arg2 = static_cast< size_t >(val2);
39487 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39488 if (!SWIG_IsOK(res3)) {
39489 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
39490 }
39491 {
39492 PyThreadState* __tstate = wxPyBeginAllowThreads();
39493 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
39494 wxPyEndAllowThreads(__tstate);
39495 if (PyErr_Occurred()) SWIG_fail;
39496 }
39497 {
39498 resultobj = wxPyMake_wxObject(result, (bool)0);
39499 }
39500 return resultobj;
39501 fail:
39502 return NULL;
39503 }
39504
39505
39506 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39507 PyObject *resultobj = 0;
39508 wxMenu *arg1 = (wxMenu *) 0 ;
39509 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39510 wxMenuItem *result = 0 ;
39511 void *argp1 = 0 ;
39512 int res1 = 0 ;
39513 int res2 = 0 ;
39514 PyObject * obj0 = 0 ;
39515 PyObject * obj1 = 0 ;
39516 char * kwnames[] = {
39517 (char *) "self",(char *) "item", NULL
39518 };
39519
39520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
39521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39522 if (!SWIG_IsOK(res1)) {
39523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39524 }
39525 arg1 = reinterpret_cast< wxMenu * >(argp1);
39526 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
39527 if (!SWIG_IsOK(res2)) {
39528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39529 }
39530 {
39531 PyThreadState* __tstate = wxPyBeginAllowThreads();
39532 result = (wxMenuItem *)(arg1)->Prepend(arg2);
39533 wxPyEndAllowThreads(__tstate);
39534 if (PyErr_Occurred()) SWIG_fail;
39535 }
39536 {
39537 resultobj = wxPyMake_wxObject(result, (bool)0);
39538 }
39539 return resultobj;
39540 fail:
39541 return NULL;
39542 }
39543
39544
39545 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39546 PyObject *resultobj = 0;
39547 wxMenu *arg1 = (wxMenu *) 0 ;
39548 void *argp1 = 0 ;
39549 int res1 = 0 ;
39550 PyObject *swig_obj[1] ;
39551
39552 if (!args) SWIG_fail;
39553 swig_obj[0] = args;
39554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39555 if (!SWIG_IsOK(res1)) {
39556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
39557 }
39558 arg1 = reinterpret_cast< wxMenu * >(argp1);
39559 {
39560 PyThreadState* __tstate = wxPyBeginAllowThreads();
39561 (arg1)->Break();
39562 wxPyEndAllowThreads(__tstate);
39563 if (PyErr_Occurred()) SWIG_fail;
39564 }
39565 resultobj = SWIG_Py_Void();
39566 return resultobj;
39567 fail:
39568 return NULL;
39569 }
39570
39571
39572 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39573 PyObject *resultobj = 0;
39574 wxMenu *arg1 = (wxMenu *) 0 ;
39575 size_t arg2 ;
39576 int arg3 ;
39577 wxString const &arg4_defvalue = wxPyEmptyString ;
39578 wxString *arg4 = (wxString *) &arg4_defvalue ;
39579 wxString const &arg5_defvalue = wxPyEmptyString ;
39580 wxString *arg5 = (wxString *) &arg5_defvalue ;
39581 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
39582 wxMenuItem *result = 0 ;
39583 void *argp1 = 0 ;
39584 int res1 = 0 ;
39585 size_t val2 ;
39586 int ecode2 = 0 ;
39587 int val3 ;
39588 int ecode3 = 0 ;
39589 bool temp4 = false ;
39590 bool temp5 = false ;
39591 int val6 ;
39592 int ecode6 = 0 ;
39593 PyObject * obj0 = 0 ;
39594 PyObject * obj1 = 0 ;
39595 PyObject * obj2 = 0 ;
39596 PyObject * obj3 = 0 ;
39597 PyObject * obj4 = 0 ;
39598 PyObject * obj5 = 0 ;
39599 char * kwnames[] = {
39600 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39601 };
39602
39603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39605 if (!SWIG_IsOK(res1)) {
39606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
39607 }
39608 arg1 = reinterpret_cast< wxMenu * >(argp1);
39609 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39610 if (!SWIG_IsOK(ecode2)) {
39611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
39612 }
39613 arg2 = static_cast< size_t >(val2);
39614 ecode3 = SWIG_AsVal_int(obj2, &val3);
39615 if (!SWIG_IsOK(ecode3)) {
39616 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
39617 }
39618 arg3 = static_cast< int >(val3);
39619 if (obj3) {
39620 {
39621 arg4 = wxString_in_helper(obj3);
39622 if (arg4 == NULL) SWIG_fail;
39623 temp4 = true;
39624 }
39625 }
39626 if (obj4) {
39627 {
39628 arg5 = wxString_in_helper(obj4);
39629 if (arg5 == NULL) SWIG_fail;
39630 temp5 = true;
39631 }
39632 }
39633 if (obj5) {
39634 ecode6 = SWIG_AsVal_int(obj5, &val6);
39635 if (!SWIG_IsOK(ecode6)) {
39636 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
39637 }
39638 arg6 = static_cast< wxItemKind >(val6);
39639 }
39640 {
39641 PyThreadState* __tstate = wxPyBeginAllowThreads();
39642 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
39643 wxPyEndAllowThreads(__tstate);
39644 if (PyErr_Occurred()) SWIG_fail;
39645 }
39646 {
39647 resultobj = wxPyMake_wxObject(result, (bool)0);
39648 }
39649 {
39650 if (temp4)
39651 delete arg4;
39652 }
39653 {
39654 if (temp5)
39655 delete arg5;
39656 }
39657 return resultobj;
39658 fail:
39659 {
39660 if (temp4)
39661 delete arg4;
39662 }
39663 {
39664 if (temp5)
39665 delete arg5;
39666 }
39667 return NULL;
39668 }
39669
39670
39671 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39672 PyObject *resultobj = 0;
39673 wxMenu *arg1 = (wxMenu *) 0 ;
39674 size_t arg2 ;
39675 wxMenuItem *result = 0 ;
39676 void *argp1 = 0 ;
39677 int res1 = 0 ;
39678 size_t val2 ;
39679 int ecode2 = 0 ;
39680 PyObject * obj0 = 0 ;
39681 PyObject * obj1 = 0 ;
39682 char * kwnames[] = {
39683 (char *) "self",(char *) "pos", NULL
39684 };
39685
39686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39688 if (!SWIG_IsOK(res1)) {
39689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39690 }
39691 arg1 = reinterpret_cast< wxMenu * >(argp1);
39692 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39693 if (!SWIG_IsOK(ecode2)) {
39694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39695 }
39696 arg2 = static_cast< size_t >(val2);
39697 {
39698 PyThreadState* __tstate = wxPyBeginAllowThreads();
39699 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39700 wxPyEndAllowThreads(__tstate);
39701 if (PyErr_Occurred()) SWIG_fail;
39702 }
39703 {
39704 resultobj = wxPyMake_wxObject(result, (bool)0);
39705 }
39706 return resultobj;
39707 fail:
39708 return NULL;
39709 }
39710
39711
39712 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39713 PyObject *resultobj = 0;
39714 wxMenu *arg1 = (wxMenu *) 0 ;
39715 size_t arg2 ;
39716 int arg3 ;
39717 wxString *arg4 = 0 ;
39718 wxString const &arg5_defvalue = wxPyEmptyString ;
39719 wxString *arg5 = (wxString *) &arg5_defvalue ;
39720 wxMenuItem *result = 0 ;
39721 void *argp1 = 0 ;
39722 int res1 = 0 ;
39723 size_t val2 ;
39724 int ecode2 = 0 ;
39725 int val3 ;
39726 int ecode3 = 0 ;
39727 bool temp4 = false ;
39728 bool temp5 = false ;
39729 PyObject * obj0 = 0 ;
39730 PyObject * obj1 = 0 ;
39731 PyObject * obj2 = 0 ;
39732 PyObject * obj3 = 0 ;
39733 PyObject * obj4 = 0 ;
39734 char * kwnames[] = {
39735 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39736 };
39737
39738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39740 if (!SWIG_IsOK(res1)) {
39741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39742 }
39743 arg1 = reinterpret_cast< wxMenu * >(argp1);
39744 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39745 if (!SWIG_IsOK(ecode2)) {
39746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39747 }
39748 arg2 = static_cast< size_t >(val2);
39749 ecode3 = SWIG_AsVal_int(obj2, &val3);
39750 if (!SWIG_IsOK(ecode3)) {
39751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39752 }
39753 arg3 = static_cast< int >(val3);
39754 {
39755 arg4 = wxString_in_helper(obj3);
39756 if (arg4 == NULL) SWIG_fail;
39757 temp4 = true;
39758 }
39759 if (obj4) {
39760 {
39761 arg5 = wxString_in_helper(obj4);
39762 if (arg5 == NULL) SWIG_fail;
39763 temp5 = true;
39764 }
39765 }
39766 {
39767 PyThreadState* __tstate = wxPyBeginAllowThreads();
39768 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39769 wxPyEndAllowThreads(__tstate);
39770 if (PyErr_Occurred()) SWIG_fail;
39771 }
39772 {
39773 resultobj = wxPyMake_wxObject(result, (bool)0);
39774 }
39775 {
39776 if (temp4)
39777 delete arg4;
39778 }
39779 {
39780 if (temp5)
39781 delete arg5;
39782 }
39783 return resultobj;
39784 fail:
39785 {
39786 if (temp4)
39787 delete arg4;
39788 }
39789 {
39790 if (temp5)
39791 delete arg5;
39792 }
39793 return NULL;
39794 }
39795
39796
39797 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39798 PyObject *resultobj = 0;
39799 wxMenu *arg1 = (wxMenu *) 0 ;
39800 size_t arg2 ;
39801 int arg3 ;
39802 wxString *arg4 = 0 ;
39803 wxString const &arg5_defvalue = wxPyEmptyString ;
39804 wxString *arg5 = (wxString *) &arg5_defvalue ;
39805 wxMenuItem *result = 0 ;
39806 void *argp1 = 0 ;
39807 int res1 = 0 ;
39808 size_t val2 ;
39809 int ecode2 = 0 ;
39810 int val3 ;
39811 int ecode3 = 0 ;
39812 bool temp4 = false ;
39813 bool temp5 = false ;
39814 PyObject * obj0 = 0 ;
39815 PyObject * obj1 = 0 ;
39816 PyObject * obj2 = 0 ;
39817 PyObject * obj3 = 0 ;
39818 PyObject * obj4 = 0 ;
39819 char * kwnames[] = {
39820 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39821 };
39822
39823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39825 if (!SWIG_IsOK(res1)) {
39826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39827 }
39828 arg1 = reinterpret_cast< wxMenu * >(argp1);
39829 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39830 if (!SWIG_IsOK(ecode2)) {
39831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39832 }
39833 arg2 = static_cast< size_t >(val2);
39834 ecode3 = SWIG_AsVal_int(obj2, &val3);
39835 if (!SWIG_IsOK(ecode3)) {
39836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39837 }
39838 arg3 = static_cast< int >(val3);
39839 {
39840 arg4 = wxString_in_helper(obj3);
39841 if (arg4 == NULL) SWIG_fail;
39842 temp4 = true;
39843 }
39844 if (obj4) {
39845 {
39846 arg5 = wxString_in_helper(obj4);
39847 if (arg5 == NULL) SWIG_fail;
39848 temp5 = true;
39849 }
39850 }
39851 {
39852 PyThreadState* __tstate = wxPyBeginAllowThreads();
39853 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39854 wxPyEndAllowThreads(__tstate);
39855 if (PyErr_Occurred()) SWIG_fail;
39856 }
39857 {
39858 resultobj = wxPyMake_wxObject(result, (bool)0);
39859 }
39860 {
39861 if (temp4)
39862 delete arg4;
39863 }
39864 {
39865 if (temp5)
39866 delete arg5;
39867 }
39868 return resultobj;
39869 fail:
39870 {
39871 if (temp4)
39872 delete arg4;
39873 }
39874 {
39875 if (temp5)
39876 delete arg5;
39877 }
39878 return NULL;
39879 }
39880
39881
39882 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39883 PyObject *resultobj = 0;
39884 wxMenu *arg1 = (wxMenu *) 0 ;
39885 size_t arg2 ;
39886 int arg3 ;
39887 wxString *arg4 = 0 ;
39888 wxMenu *arg5 = (wxMenu *) 0 ;
39889 wxString const &arg6_defvalue = wxPyEmptyString ;
39890 wxString *arg6 = (wxString *) &arg6_defvalue ;
39891 wxMenuItem *result = 0 ;
39892 void *argp1 = 0 ;
39893 int res1 = 0 ;
39894 size_t val2 ;
39895 int ecode2 = 0 ;
39896 int val3 ;
39897 int ecode3 = 0 ;
39898 bool temp4 = false ;
39899 void *argp5 = 0 ;
39900 int res5 = 0 ;
39901 bool temp6 = false ;
39902 PyObject * obj0 = 0 ;
39903 PyObject * obj1 = 0 ;
39904 PyObject * obj2 = 0 ;
39905 PyObject * obj3 = 0 ;
39906 PyObject * obj4 = 0 ;
39907 PyObject * obj5 = 0 ;
39908 char * kwnames[] = {
39909 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39910 };
39911
39912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39914 if (!SWIG_IsOK(res1)) {
39915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39916 }
39917 arg1 = reinterpret_cast< wxMenu * >(argp1);
39918 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39919 if (!SWIG_IsOK(ecode2)) {
39920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39921 }
39922 arg2 = static_cast< size_t >(val2);
39923 ecode3 = SWIG_AsVal_int(obj2, &val3);
39924 if (!SWIG_IsOK(ecode3)) {
39925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39926 }
39927 arg3 = static_cast< int >(val3);
39928 {
39929 arg4 = wxString_in_helper(obj3);
39930 if (arg4 == NULL) SWIG_fail;
39931 temp4 = true;
39932 }
39933 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39934 if (!SWIG_IsOK(res5)) {
39935 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39936 }
39937 arg5 = reinterpret_cast< wxMenu * >(argp5);
39938 if (obj5) {
39939 {
39940 arg6 = wxString_in_helper(obj5);
39941 if (arg6 == NULL) SWIG_fail;
39942 temp6 = true;
39943 }
39944 }
39945 {
39946 PyThreadState* __tstate = wxPyBeginAllowThreads();
39947 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39948 wxPyEndAllowThreads(__tstate);
39949 if (PyErr_Occurred()) SWIG_fail;
39950 }
39951 {
39952 resultobj = wxPyMake_wxObject(result, (bool)0);
39953 }
39954 {
39955 if (temp4)
39956 delete arg4;
39957 }
39958 {
39959 if (temp6)
39960 delete arg6;
39961 }
39962 return resultobj;
39963 fail:
39964 {
39965 if (temp4)
39966 delete arg4;
39967 }
39968 {
39969 if (temp6)
39970 delete arg6;
39971 }
39972 return NULL;
39973 }
39974
39975
39976 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39977 PyObject *resultobj = 0;
39978 wxMenu *arg1 = (wxMenu *) 0 ;
39979 int arg2 ;
39980 wxString const &arg3_defvalue = wxPyEmptyString ;
39981 wxString *arg3 = (wxString *) &arg3_defvalue ;
39982 wxString const &arg4_defvalue = wxPyEmptyString ;
39983 wxString *arg4 = (wxString *) &arg4_defvalue ;
39984 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39985 wxMenuItem *result = 0 ;
39986 void *argp1 = 0 ;
39987 int res1 = 0 ;
39988 int val2 ;
39989 int ecode2 = 0 ;
39990 bool temp3 = false ;
39991 bool temp4 = false ;
39992 int val5 ;
39993 int ecode5 = 0 ;
39994 PyObject * obj0 = 0 ;
39995 PyObject * obj1 = 0 ;
39996 PyObject * obj2 = 0 ;
39997 PyObject * obj3 = 0 ;
39998 PyObject * obj4 = 0 ;
39999 char * kwnames[] = {
40000 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
40001 };
40002
40003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40005 if (!SWIG_IsOK(res1)) {
40006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
40007 }
40008 arg1 = reinterpret_cast< wxMenu * >(argp1);
40009 ecode2 = SWIG_AsVal_int(obj1, &val2);
40010 if (!SWIG_IsOK(ecode2)) {
40011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
40012 }
40013 arg2 = static_cast< int >(val2);
40014 if (obj2) {
40015 {
40016 arg3 = wxString_in_helper(obj2);
40017 if (arg3 == NULL) SWIG_fail;
40018 temp3 = true;
40019 }
40020 }
40021 if (obj3) {
40022 {
40023 arg4 = wxString_in_helper(obj3);
40024 if (arg4 == NULL) SWIG_fail;
40025 temp4 = true;
40026 }
40027 }
40028 if (obj4) {
40029 ecode5 = SWIG_AsVal_int(obj4, &val5);
40030 if (!SWIG_IsOK(ecode5)) {
40031 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
40032 }
40033 arg5 = static_cast< wxItemKind >(val5);
40034 }
40035 {
40036 PyThreadState* __tstate = wxPyBeginAllowThreads();
40037 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
40038 wxPyEndAllowThreads(__tstate);
40039 if (PyErr_Occurred()) SWIG_fail;
40040 }
40041 {
40042 resultobj = wxPyMake_wxObject(result, (bool)0);
40043 }
40044 {
40045 if (temp3)
40046 delete arg3;
40047 }
40048 {
40049 if (temp4)
40050 delete arg4;
40051 }
40052 return resultobj;
40053 fail:
40054 {
40055 if (temp3)
40056 delete arg3;
40057 }
40058 {
40059 if (temp4)
40060 delete arg4;
40061 }
40062 return NULL;
40063 }
40064
40065
40066 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40067 PyObject *resultobj = 0;
40068 wxMenu *arg1 = (wxMenu *) 0 ;
40069 wxMenuItem *result = 0 ;
40070 void *argp1 = 0 ;
40071 int res1 = 0 ;
40072 PyObject *swig_obj[1] ;
40073
40074 if (!args) SWIG_fail;
40075 swig_obj[0] = args;
40076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40077 if (!SWIG_IsOK(res1)) {
40078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
40079 }
40080 arg1 = reinterpret_cast< wxMenu * >(argp1);
40081 {
40082 PyThreadState* __tstate = wxPyBeginAllowThreads();
40083 result = (wxMenuItem *)(arg1)->PrependSeparator();
40084 wxPyEndAllowThreads(__tstate);
40085 if (PyErr_Occurred()) SWIG_fail;
40086 }
40087 {
40088 resultobj = wxPyMake_wxObject(result, (bool)0);
40089 }
40090 return resultobj;
40091 fail:
40092 return NULL;
40093 }
40094
40095
40096 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40097 PyObject *resultobj = 0;
40098 wxMenu *arg1 = (wxMenu *) 0 ;
40099 int arg2 ;
40100 wxString *arg3 = 0 ;
40101 wxString const &arg4_defvalue = wxPyEmptyString ;
40102 wxString *arg4 = (wxString *) &arg4_defvalue ;
40103 wxMenuItem *result = 0 ;
40104 void *argp1 = 0 ;
40105 int res1 = 0 ;
40106 int val2 ;
40107 int ecode2 = 0 ;
40108 bool temp3 = false ;
40109 bool temp4 = false ;
40110 PyObject * obj0 = 0 ;
40111 PyObject * obj1 = 0 ;
40112 PyObject * obj2 = 0 ;
40113 PyObject * obj3 = 0 ;
40114 char * kwnames[] = {
40115 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40116 };
40117
40118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40120 if (!SWIG_IsOK(res1)) {
40121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40122 }
40123 arg1 = reinterpret_cast< wxMenu * >(argp1);
40124 ecode2 = SWIG_AsVal_int(obj1, &val2);
40125 if (!SWIG_IsOK(ecode2)) {
40126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
40127 }
40128 arg2 = static_cast< int >(val2);
40129 {
40130 arg3 = wxString_in_helper(obj2);
40131 if (arg3 == NULL) SWIG_fail;
40132 temp3 = true;
40133 }
40134 if (obj3) {
40135 {
40136 arg4 = wxString_in_helper(obj3);
40137 if (arg4 == NULL) SWIG_fail;
40138 temp4 = true;
40139 }
40140 }
40141 {
40142 PyThreadState* __tstate = wxPyBeginAllowThreads();
40143 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40144 wxPyEndAllowThreads(__tstate);
40145 if (PyErr_Occurred()) SWIG_fail;
40146 }
40147 {
40148 resultobj = wxPyMake_wxObject(result, (bool)0);
40149 }
40150 {
40151 if (temp3)
40152 delete arg3;
40153 }
40154 {
40155 if (temp4)
40156 delete arg4;
40157 }
40158 return resultobj;
40159 fail:
40160 {
40161 if (temp3)
40162 delete arg3;
40163 }
40164 {
40165 if (temp4)
40166 delete arg4;
40167 }
40168 return NULL;
40169 }
40170
40171
40172 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40173 PyObject *resultobj = 0;
40174 wxMenu *arg1 = (wxMenu *) 0 ;
40175 int arg2 ;
40176 wxString *arg3 = 0 ;
40177 wxString const &arg4_defvalue = wxPyEmptyString ;
40178 wxString *arg4 = (wxString *) &arg4_defvalue ;
40179 wxMenuItem *result = 0 ;
40180 void *argp1 = 0 ;
40181 int res1 = 0 ;
40182 int val2 ;
40183 int ecode2 = 0 ;
40184 bool temp3 = false ;
40185 bool temp4 = false ;
40186 PyObject * obj0 = 0 ;
40187 PyObject * obj1 = 0 ;
40188 PyObject * obj2 = 0 ;
40189 PyObject * obj3 = 0 ;
40190 char * kwnames[] = {
40191 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
40192 };
40193
40194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40196 if (!SWIG_IsOK(res1)) {
40197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40198 }
40199 arg1 = reinterpret_cast< wxMenu * >(argp1);
40200 ecode2 = SWIG_AsVal_int(obj1, &val2);
40201 if (!SWIG_IsOK(ecode2)) {
40202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
40203 }
40204 arg2 = static_cast< int >(val2);
40205 {
40206 arg3 = wxString_in_helper(obj2);
40207 if (arg3 == NULL) SWIG_fail;
40208 temp3 = true;
40209 }
40210 if (obj3) {
40211 {
40212 arg4 = wxString_in_helper(obj3);
40213 if (arg4 == NULL) SWIG_fail;
40214 temp4 = true;
40215 }
40216 }
40217 {
40218 PyThreadState* __tstate = wxPyBeginAllowThreads();
40219 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
40220 wxPyEndAllowThreads(__tstate);
40221 if (PyErr_Occurred()) SWIG_fail;
40222 }
40223 {
40224 resultobj = wxPyMake_wxObject(result, (bool)0);
40225 }
40226 {
40227 if (temp3)
40228 delete arg3;
40229 }
40230 {
40231 if (temp4)
40232 delete arg4;
40233 }
40234 return resultobj;
40235 fail:
40236 {
40237 if (temp3)
40238 delete arg3;
40239 }
40240 {
40241 if (temp4)
40242 delete arg4;
40243 }
40244 return NULL;
40245 }
40246
40247
40248 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40249 PyObject *resultobj = 0;
40250 wxMenu *arg1 = (wxMenu *) 0 ;
40251 int arg2 ;
40252 wxString *arg3 = 0 ;
40253 wxMenu *arg4 = (wxMenu *) 0 ;
40254 wxString const &arg5_defvalue = wxPyEmptyString ;
40255 wxString *arg5 = (wxString *) &arg5_defvalue ;
40256 wxMenuItem *result = 0 ;
40257 void *argp1 = 0 ;
40258 int res1 = 0 ;
40259 int val2 ;
40260 int ecode2 = 0 ;
40261 bool temp3 = false ;
40262 void *argp4 = 0 ;
40263 int res4 = 0 ;
40264 bool temp5 = false ;
40265 PyObject * obj0 = 0 ;
40266 PyObject * obj1 = 0 ;
40267 PyObject * obj2 = 0 ;
40268 PyObject * obj3 = 0 ;
40269 PyObject * obj4 = 0 ;
40270 char * kwnames[] = {
40271 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
40272 };
40273
40274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
40275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40276 if (!SWIG_IsOK(res1)) {
40277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
40278 }
40279 arg1 = reinterpret_cast< wxMenu * >(argp1);
40280 ecode2 = SWIG_AsVal_int(obj1, &val2);
40281 if (!SWIG_IsOK(ecode2)) {
40282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
40283 }
40284 arg2 = static_cast< int >(val2);
40285 {
40286 arg3 = wxString_in_helper(obj2);
40287 if (arg3 == NULL) SWIG_fail;
40288 temp3 = true;
40289 }
40290 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
40291 if (!SWIG_IsOK(res4)) {
40292 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
40293 }
40294 arg4 = reinterpret_cast< wxMenu * >(argp4);
40295 if (obj4) {
40296 {
40297 arg5 = wxString_in_helper(obj4);
40298 if (arg5 == NULL) SWIG_fail;
40299 temp5 = true;
40300 }
40301 }
40302 {
40303 PyThreadState* __tstate = wxPyBeginAllowThreads();
40304 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
40305 wxPyEndAllowThreads(__tstate);
40306 if (PyErr_Occurred()) SWIG_fail;
40307 }
40308 {
40309 resultobj = wxPyMake_wxObject(result, (bool)0);
40310 }
40311 {
40312 if (temp3)
40313 delete arg3;
40314 }
40315 {
40316 if (temp5)
40317 delete arg5;
40318 }
40319 return resultobj;
40320 fail:
40321 {
40322 if (temp3)
40323 delete arg3;
40324 }
40325 {
40326 if (temp5)
40327 delete arg5;
40328 }
40329 return NULL;
40330 }
40331
40332
40333 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40334 PyObject *resultobj = 0;
40335 wxMenu *arg1 = (wxMenu *) 0 ;
40336 int arg2 ;
40337 wxMenuItem *result = 0 ;
40338 void *argp1 = 0 ;
40339 int res1 = 0 ;
40340 int val2 ;
40341 int ecode2 = 0 ;
40342 PyObject * obj0 = 0 ;
40343 PyObject * obj1 = 0 ;
40344 char * kwnames[] = {
40345 (char *) "self",(char *) "id", NULL
40346 };
40347
40348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40350 if (!SWIG_IsOK(res1)) {
40351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
40352 }
40353 arg1 = reinterpret_cast< wxMenu * >(argp1);
40354 ecode2 = SWIG_AsVal_int(obj1, &val2);
40355 if (!SWIG_IsOK(ecode2)) {
40356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
40357 }
40358 arg2 = static_cast< int >(val2);
40359 {
40360 PyThreadState* __tstate = wxPyBeginAllowThreads();
40361 result = (wxMenuItem *)(arg1)->Remove(arg2);
40362 wxPyEndAllowThreads(__tstate);
40363 if (PyErr_Occurred()) SWIG_fail;
40364 }
40365 {
40366 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40367 }
40368 return resultobj;
40369 fail:
40370 return NULL;
40371 }
40372
40373
40374 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40375 PyObject *resultobj = 0;
40376 wxMenu *arg1 = (wxMenu *) 0 ;
40377 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40378 wxMenuItem *result = 0 ;
40379 void *argp1 = 0 ;
40380 int res1 = 0 ;
40381 void *argp2 = 0 ;
40382 int res2 = 0 ;
40383 PyObject * obj0 = 0 ;
40384 PyObject * obj1 = 0 ;
40385 char * kwnames[] = {
40386 (char *) "self",(char *) "item", NULL
40387 };
40388
40389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
40390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40391 if (!SWIG_IsOK(res1)) {
40392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40393 }
40394 arg1 = reinterpret_cast< wxMenu * >(argp1);
40395 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40396 if (!SWIG_IsOK(res2)) {
40397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40398 }
40399 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40400 {
40401 PyThreadState* __tstate = wxPyBeginAllowThreads();
40402 result = (wxMenuItem *)(arg1)->Remove(arg2);
40403 wxPyEndAllowThreads(__tstate);
40404 if (PyErr_Occurred()) SWIG_fail;
40405 }
40406 {
40407 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
40408 }
40409 return resultobj;
40410 fail:
40411 return NULL;
40412 }
40413
40414
40415 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40416 PyObject *resultobj = 0;
40417 wxMenu *arg1 = (wxMenu *) 0 ;
40418 int arg2 ;
40419 bool result;
40420 void *argp1 = 0 ;
40421 int res1 = 0 ;
40422 int val2 ;
40423 int ecode2 = 0 ;
40424 PyObject * obj0 = 0 ;
40425 PyObject * obj1 = 0 ;
40426 char * kwnames[] = {
40427 (char *) "self",(char *) "id", NULL
40428 };
40429
40430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
40431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40432 if (!SWIG_IsOK(res1)) {
40433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
40434 }
40435 arg1 = reinterpret_cast< wxMenu * >(argp1);
40436 ecode2 = SWIG_AsVal_int(obj1, &val2);
40437 if (!SWIG_IsOK(ecode2)) {
40438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
40439 }
40440 arg2 = static_cast< int >(val2);
40441 {
40442 PyThreadState* __tstate = wxPyBeginAllowThreads();
40443 result = (bool)(arg1)->Delete(arg2);
40444 wxPyEndAllowThreads(__tstate);
40445 if (PyErr_Occurred()) SWIG_fail;
40446 }
40447 {
40448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40449 }
40450 return resultobj;
40451 fail:
40452 return NULL;
40453 }
40454
40455
40456 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40457 PyObject *resultobj = 0;
40458 wxMenu *arg1 = (wxMenu *) 0 ;
40459 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40460 bool result;
40461 void *argp1 = 0 ;
40462 int res1 = 0 ;
40463 void *argp2 = 0 ;
40464 int res2 = 0 ;
40465 PyObject * obj0 = 0 ;
40466 PyObject * obj1 = 0 ;
40467 char * kwnames[] = {
40468 (char *) "self",(char *) "item", NULL
40469 };
40470
40471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
40472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40473 if (!SWIG_IsOK(res1)) {
40474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40475 }
40476 arg1 = reinterpret_cast< wxMenu * >(argp1);
40477 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40478 if (!SWIG_IsOK(res2)) {
40479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40480 }
40481 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40482 {
40483 PyThreadState* __tstate = wxPyBeginAllowThreads();
40484 result = (bool)(arg1)->Delete(arg2);
40485 wxPyEndAllowThreads(__tstate);
40486 if (PyErr_Occurred()) SWIG_fail;
40487 }
40488 {
40489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40490 }
40491 return resultobj;
40492 fail:
40493 return NULL;
40494 }
40495
40496
40497 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40498 PyObject *resultobj = 0;
40499 wxMenu *arg1 = (wxMenu *) 0 ;
40500 void *argp1 = 0 ;
40501 int res1 = 0 ;
40502 PyObject *swig_obj[1] ;
40503
40504 if (!args) SWIG_fail;
40505 swig_obj[0] = args;
40506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40507 if (!SWIG_IsOK(res1)) {
40508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
40509 }
40510 arg1 = reinterpret_cast< wxMenu * >(argp1);
40511 {
40512 PyThreadState* __tstate = wxPyBeginAllowThreads();
40513 wxMenu_Destroy(arg1);
40514 wxPyEndAllowThreads(__tstate);
40515 if (PyErr_Occurred()) SWIG_fail;
40516 }
40517 resultobj = SWIG_Py_Void();
40518 return resultobj;
40519 fail:
40520 return NULL;
40521 }
40522
40523
40524 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40525 PyObject *resultobj = 0;
40526 wxMenu *arg1 = (wxMenu *) 0 ;
40527 int arg2 ;
40528 bool result;
40529 void *argp1 = 0 ;
40530 int res1 = 0 ;
40531 int val2 ;
40532 int ecode2 = 0 ;
40533 PyObject * obj0 = 0 ;
40534 PyObject * obj1 = 0 ;
40535 char * kwnames[] = {
40536 (char *) "self",(char *) "id", NULL
40537 };
40538
40539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
40540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40541 if (!SWIG_IsOK(res1)) {
40542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
40543 }
40544 arg1 = reinterpret_cast< wxMenu * >(argp1);
40545 ecode2 = SWIG_AsVal_int(obj1, &val2);
40546 if (!SWIG_IsOK(ecode2)) {
40547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
40548 }
40549 arg2 = static_cast< int >(val2);
40550 {
40551 PyThreadState* __tstate = wxPyBeginAllowThreads();
40552 result = (bool)(arg1)->Destroy(arg2);
40553 wxPyEndAllowThreads(__tstate);
40554 if (PyErr_Occurred()) SWIG_fail;
40555 }
40556 {
40557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40558 }
40559 return resultobj;
40560 fail:
40561 return NULL;
40562 }
40563
40564
40565 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40566 PyObject *resultobj = 0;
40567 wxMenu *arg1 = (wxMenu *) 0 ;
40568 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
40569 bool result;
40570 void *argp1 = 0 ;
40571 int res1 = 0 ;
40572 void *argp2 = 0 ;
40573 int res2 = 0 ;
40574 PyObject * obj0 = 0 ;
40575 PyObject * obj1 = 0 ;
40576 char * kwnames[] = {
40577 (char *) "self",(char *) "item", NULL
40578 };
40579
40580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
40581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40582 if (!SWIG_IsOK(res1)) {
40583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
40584 }
40585 arg1 = reinterpret_cast< wxMenu * >(argp1);
40586 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
40587 if (!SWIG_IsOK(res2)) {
40588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
40589 }
40590 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
40591 {
40592 PyThreadState* __tstate = wxPyBeginAllowThreads();
40593 result = (bool)(arg1)->Destroy(arg2);
40594 wxPyEndAllowThreads(__tstate);
40595 if (PyErr_Occurred()) SWIG_fail;
40596 }
40597 {
40598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40599 }
40600 return resultobj;
40601 fail:
40602 return NULL;
40603 }
40604
40605
40606 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40607 PyObject *resultobj = 0;
40608 wxMenu *arg1 = (wxMenu *) 0 ;
40609 size_t result;
40610 void *argp1 = 0 ;
40611 int res1 = 0 ;
40612 PyObject *swig_obj[1] ;
40613
40614 if (!args) SWIG_fail;
40615 swig_obj[0] = args;
40616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40617 if (!SWIG_IsOK(res1)) {
40618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
40619 }
40620 arg1 = reinterpret_cast< wxMenu * >(argp1);
40621 {
40622 PyThreadState* __tstate = wxPyBeginAllowThreads();
40623 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
40624 wxPyEndAllowThreads(__tstate);
40625 if (PyErr_Occurred()) SWIG_fail;
40626 }
40627 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40628 return resultobj;
40629 fail:
40630 return NULL;
40631 }
40632
40633
40634 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40635 PyObject *resultobj = 0;
40636 wxMenu *arg1 = (wxMenu *) 0 ;
40637 PyObject *result = 0 ;
40638 void *argp1 = 0 ;
40639 int res1 = 0 ;
40640 PyObject *swig_obj[1] ;
40641
40642 if (!args) SWIG_fail;
40643 swig_obj[0] = args;
40644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40645 if (!SWIG_IsOK(res1)) {
40646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
40647 }
40648 arg1 = reinterpret_cast< wxMenu * >(argp1);
40649 {
40650 PyThreadState* __tstate = wxPyBeginAllowThreads();
40651 result = (PyObject *)wxMenu_GetMenuItems(arg1);
40652 wxPyEndAllowThreads(__tstate);
40653 if (PyErr_Occurred()) SWIG_fail;
40654 }
40655 resultobj = result;
40656 return resultobj;
40657 fail:
40658 return NULL;
40659 }
40660
40661
40662 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40663 PyObject *resultobj = 0;
40664 wxMenu *arg1 = (wxMenu *) 0 ;
40665 wxString *arg2 = 0 ;
40666 int result;
40667 void *argp1 = 0 ;
40668 int res1 = 0 ;
40669 bool temp2 = false ;
40670 PyObject * obj0 = 0 ;
40671 PyObject * obj1 = 0 ;
40672 char * kwnames[] = {
40673 (char *) "self",(char *) "item", NULL
40674 };
40675
40676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40678 if (!SWIG_IsOK(res1)) {
40679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40680 }
40681 arg1 = reinterpret_cast< wxMenu * >(argp1);
40682 {
40683 arg2 = wxString_in_helper(obj1);
40684 if (arg2 == NULL) SWIG_fail;
40685 temp2 = true;
40686 }
40687 {
40688 PyThreadState* __tstate = wxPyBeginAllowThreads();
40689 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40690 wxPyEndAllowThreads(__tstate);
40691 if (PyErr_Occurred()) SWIG_fail;
40692 }
40693 resultobj = SWIG_From_int(static_cast< int >(result));
40694 {
40695 if (temp2)
40696 delete arg2;
40697 }
40698 return resultobj;
40699 fail:
40700 {
40701 if (temp2)
40702 delete arg2;
40703 }
40704 return NULL;
40705 }
40706
40707
40708 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40709 PyObject *resultobj = 0;
40710 wxMenu *arg1 = (wxMenu *) 0 ;
40711 int arg2 ;
40712 wxMenuItem *result = 0 ;
40713 void *argp1 = 0 ;
40714 int res1 = 0 ;
40715 int val2 ;
40716 int ecode2 = 0 ;
40717 PyObject * obj0 = 0 ;
40718 PyObject * obj1 = 0 ;
40719 char * kwnames[] = {
40720 (char *) "self",(char *) "id", NULL
40721 };
40722
40723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40725 if (!SWIG_IsOK(res1)) {
40726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40727 }
40728 arg1 = reinterpret_cast< wxMenu * >(argp1);
40729 ecode2 = SWIG_AsVal_int(obj1, &val2);
40730 if (!SWIG_IsOK(ecode2)) {
40731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40732 }
40733 arg2 = static_cast< int >(val2);
40734 {
40735 PyThreadState* __tstate = wxPyBeginAllowThreads();
40736 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40737 wxPyEndAllowThreads(__tstate);
40738 if (PyErr_Occurred()) SWIG_fail;
40739 }
40740 {
40741 resultobj = wxPyMake_wxObject(result, (bool)0);
40742 }
40743 return resultobj;
40744 fail:
40745 return NULL;
40746 }
40747
40748
40749 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40750 PyObject *resultobj = 0;
40751 wxMenu *arg1 = (wxMenu *) 0 ;
40752 size_t arg2 ;
40753 wxMenuItem *result = 0 ;
40754 void *argp1 = 0 ;
40755 int res1 = 0 ;
40756 size_t val2 ;
40757 int ecode2 = 0 ;
40758 PyObject * obj0 = 0 ;
40759 PyObject * obj1 = 0 ;
40760 char * kwnames[] = {
40761 (char *) "self",(char *) "position", NULL
40762 };
40763
40764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40766 if (!SWIG_IsOK(res1)) {
40767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40768 }
40769 arg1 = reinterpret_cast< wxMenu * >(argp1);
40770 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40771 if (!SWIG_IsOK(ecode2)) {
40772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40773 }
40774 arg2 = static_cast< size_t >(val2);
40775 {
40776 PyThreadState* __tstate = wxPyBeginAllowThreads();
40777 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40778 wxPyEndAllowThreads(__tstate);
40779 if (PyErr_Occurred()) SWIG_fail;
40780 }
40781 {
40782 resultobj = wxPyMake_wxObject(result, (bool)0);
40783 }
40784 return resultobj;
40785 fail:
40786 return NULL;
40787 }
40788
40789
40790 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40791 PyObject *resultobj = 0;
40792 wxMenu *arg1 = (wxMenu *) 0 ;
40793 int arg2 ;
40794 bool arg3 ;
40795 void *argp1 = 0 ;
40796 int res1 = 0 ;
40797 int val2 ;
40798 int ecode2 = 0 ;
40799 bool val3 ;
40800 int ecode3 = 0 ;
40801 PyObject * obj0 = 0 ;
40802 PyObject * obj1 = 0 ;
40803 PyObject * obj2 = 0 ;
40804 char * kwnames[] = {
40805 (char *) "self",(char *) "id",(char *) "enable", NULL
40806 };
40807
40808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40810 if (!SWIG_IsOK(res1)) {
40811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40812 }
40813 arg1 = reinterpret_cast< wxMenu * >(argp1);
40814 ecode2 = SWIG_AsVal_int(obj1, &val2);
40815 if (!SWIG_IsOK(ecode2)) {
40816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40817 }
40818 arg2 = static_cast< int >(val2);
40819 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40820 if (!SWIG_IsOK(ecode3)) {
40821 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40822 }
40823 arg3 = static_cast< bool >(val3);
40824 {
40825 PyThreadState* __tstate = wxPyBeginAllowThreads();
40826 (arg1)->Enable(arg2,arg3);
40827 wxPyEndAllowThreads(__tstate);
40828 if (PyErr_Occurred()) SWIG_fail;
40829 }
40830 resultobj = SWIG_Py_Void();
40831 return resultobj;
40832 fail:
40833 return NULL;
40834 }
40835
40836
40837 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40838 PyObject *resultobj = 0;
40839 wxMenu *arg1 = (wxMenu *) 0 ;
40840 int arg2 ;
40841 bool result;
40842 void *argp1 = 0 ;
40843 int res1 = 0 ;
40844 int val2 ;
40845 int ecode2 = 0 ;
40846 PyObject * obj0 = 0 ;
40847 PyObject * obj1 = 0 ;
40848 char * kwnames[] = {
40849 (char *) "self",(char *) "id", NULL
40850 };
40851
40852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40854 if (!SWIG_IsOK(res1)) {
40855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40856 }
40857 arg1 = reinterpret_cast< wxMenu * >(argp1);
40858 ecode2 = SWIG_AsVal_int(obj1, &val2);
40859 if (!SWIG_IsOK(ecode2)) {
40860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40861 }
40862 arg2 = static_cast< int >(val2);
40863 {
40864 PyThreadState* __tstate = wxPyBeginAllowThreads();
40865 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40866 wxPyEndAllowThreads(__tstate);
40867 if (PyErr_Occurred()) SWIG_fail;
40868 }
40869 {
40870 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40871 }
40872 return resultobj;
40873 fail:
40874 return NULL;
40875 }
40876
40877
40878 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40879 PyObject *resultobj = 0;
40880 wxMenu *arg1 = (wxMenu *) 0 ;
40881 int arg2 ;
40882 bool arg3 ;
40883 void *argp1 = 0 ;
40884 int res1 = 0 ;
40885 int val2 ;
40886 int ecode2 = 0 ;
40887 bool val3 ;
40888 int ecode3 = 0 ;
40889 PyObject * obj0 = 0 ;
40890 PyObject * obj1 = 0 ;
40891 PyObject * obj2 = 0 ;
40892 char * kwnames[] = {
40893 (char *) "self",(char *) "id",(char *) "check", NULL
40894 };
40895
40896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40898 if (!SWIG_IsOK(res1)) {
40899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40900 }
40901 arg1 = reinterpret_cast< wxMenu * >(argp1);
40902 ecode2 = SWIG_AsVal_int(obj1, &val2);
40903 if (!SWIG_IsOK(ecode2)) {
40904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40905 }
40906 arg2 = static_cast< int >(val2);
40907 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40908 if (!SWIG_IsOK(ecode3)) {
40909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40910 }
40911 arg3 = static_cast< bool >(val3);
40912 {
40913 PyThreadState* __tstate = wxPyBeginAllowThreads();
40914 (arg1)->Check(arg2,arg3);
40915 wxPyEndAllowThreads(__tstate);
40916 if (PyErr_Occurred()) SWIG_fail;
40917 }
40918 resultobj = SWIG_Py_Void();
40919 return resultobj;
40920 fail:
40921 return NULL;
40922 }
40923
40924
40925 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40926 PyObject *resultobj = 0;
40927 wxMenu *arg1 = (wxMenu *) 0 ;
40928 int arg2 ;
40929 bool result;
40930 void *argp1 = 0 ;
40931 int res1 = 0 ;
40932 int val2 ;
40933 int ecode2 = 0 ;
40934 PyObject * obj0 = 0 ;
40935 PyObject * obj1 = 0 ;
40936 char * kwnames[] = {
40937 (char *) "self",(char *) "id", NULL
40938 };
40939
40940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40942 if (!SWIG_IsOK(res1)) {
40943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40944 }
40945 arg1 = reinterpret_cast< wxMenu * >(argp1);
40946 ecode2 = SWIG_AsVal_int(obj1, &val2);
40947 if (!SWIG_IsOK(ecode2)) {
40948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40949 }
40950 arg2 = static_cast< int >(val2);
40951 {
40952 PyThreadState* __tstate = wxPyBeginAllowThreads();
40953 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40954 wxPyEndAllowThreads(__tstate);
40955 if (PyErr_Occurred()) SWIG_fail;
40956 }
40957 {
40958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40959 }
40960 return resultobj;
40961 fail:
40962 return NULL;
40963 }
40964
40965
40966 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40967 PyObject *resultobj = 0;
40968 wxMenu *arg1 = (wxMenu *) 0 ;
40969 int arg2 ;
40970 wxString *arg3 = 0 ;
40971 void *argp1 = 0 ;
40972 int res1 = 0 ;
40973 int val2 ;
40974 int ecode2 = 0 ;
40975 bool temp3 = false ;
40976 PyObject * obj0 = 0 ;
40977 PyObject * obj1 = 0 ;
40978 PyObject * obj2 = 0 ;
40979 char * kwnames[] = {
40980 (char *) "self",(char *) "id",(char *) "label", NULL
40981 };
40982
40983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40985 if (!SWIG_IsOK(res1)) {
40986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40987 }
40988 arg1 = reinterpret_cast< wxMenu * >(argp1);
40989 ecode2 = SWIG_AsVal_int(obj1, &val2);
40990 if (!SWIG_IsOK(ecode2)) {
40991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40992 }
40993 arg2 = static_cast< int >(val2);
40994 {
40995 arg3 = wxString_in_helper(obj2);
40996 if (arg3 == NULL) SWIG_fail;
40997 temp3 = true;
40998 }
40999 {
41000 PyThreadState* __tstate = wxPyBeginAllowThreads();
41001 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41002 wxPyEndAllowThreads(__tstate);
41003 if (PyErr_Occurred()) SWIG_fail;
41004 }
41005 resultobj = SWIG_Py_Void();
41006 {
41007 if (temp3)
41008 delete arg3;
41009 }
41010 return resultobj;
41011 fail:
41012 {
41013 if (temp3)
41014 delete arg3;
41015 }
41016 return NULL;
41017 }
41018
41019
41020 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41021 PyObject *resultobj = 0;
41022 wxMenu *arg1 = (wxMenu *) 0 ;
41023 int arg2 ;
41024 wxString result;
41025 void *argp1 = 0 ;
41026 int res1 = 0 ;
41027 int val2 ;
41028 int ecode2 = 0 ;
41029 PyObject * obj0 = 0 ;
41030 PyObject * obj1 = 0 ;
41031 char * kwnames[] = {
41032 (char *) "self",(char *) "id", NULL
41033 };
41034
41035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41037 if (!SWIG_IsOK(res1)) {
41038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
41039 }
41040 arg1 = reinterpret_cast< wxMenu * >(argp1);
41041 ecode2 = SWIG_AsVal_int(obj1, &val2);
41042 if (!SWIG_IsOK(ecode2)) {
41043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
41044 }
41045 arg2 = static_cast< int >(val2);
41046 {
41047 PyThreadState* __tstate = wxPyBeginAllowThreads();
41048 result = ((wxMenu const *)arg1)->GetLabel(arg2);
41049 wxPyEndAllowThreads(__tstate);
41050 if (PyErr_Occurred()) SWIG_fail;
41051 }
41052 {
41053 #if wxUSE_UNICODE
41054 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41055 #else
41056 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41057 #endif
41058 }
41059 return resultobj;
41060 fail:
41061 return NULL;
41062 }
41063
41064
41065 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41066 PyObject *resultobj = 0;
41067 wxMenu *arg1 = (wxMenu *) 0 ;
41068 int arg2 ;
41069 wxString *arg3 = 0 ;
41070 void *argp1 = 0 ;
41071 int res1 = 0 ;
41072 int val2 ;
41073 int ecode2 = 0 ;
41074 bool temp3 = false ;
41075 PyObject * obj0 = 0 ;
41076 PyObject * obj1 = 0 ;
41077 PyObject * obj2 = 0 ;
41078 char * kwnames[] = {
41079 (char *) "self",(char *) "id",(char *) "helpString", NULL
41080 };
41081
41082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41084 if (!SWIG_IsOK(res1)) {
41085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
41086 }
41087 arg1 = reinterpret_cast< wxMenu * >(argp1);
41088 ecode2 = SWIG_AsVal_int(obj1, &val2);
41089 if (!SWIG_IsOK(ecode2)) {
41090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41091 }
41092 arg2 = static_cast< int >(val2);
41093 {
41094 arg3 = wxString_in_helper(obj2);
41095 if (arg3 == NULL) SWIG_fail;
41096 temp3 = true;
41097 }
41098 {
41099 PyThreadState* __tstate = wxPyBeginAllowThreads();
41100 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41101 wxPyEndAllowThreads(__tstate);
41102 if (PyErr_Occurred()) SWIG_fail;
41103 }
41104 resultobj = SWIG_Py_Void();
41105 {
41106 if (temp3)
41107 delete arg3;
41108 }
41109 return resultobj;
41110 fail:
41111 {
41112 if (temp3)
41113 delete arg3;
41114 }
41115 return NULL;
41116 }
41117
41118
41119 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41120 PyObject *resultobj = 0;
41121 wxMenu *arg1 = (wxMenu *) 0 ;
41122 int arg2 ;
41123 wxString result;
41124 void *argp1 = 0 ;
41125 int res1 = 0 ;
41126 int val2 ;
41127 int ecode2 = 0 ;
41128 PyObject * obj0 = 0 ;
41129 PyObject * obj1 = 0 ;
41130 char * kwnames[] = {
41131 (char *) "self",(char *) "id", NULL
41132 };
41133
41134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41136 if (!SWIG_IsOK(res1)) {
41137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
41138 }
41139 arg1 = reinterpret_cast< wxMenu * >(argp1);
41140 ecode2 = SWIG_AsVal_int(obj1, &val2);
41141 if (!SWIG_IsOK(ecode2)) {
41142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41143 }
41144 arg2 = static_cast< int >(val2);
41145 {
41146 PyThreadState* __tstate = wxPyBeginAllowThreads();
41147 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
41148 wxPyEndAllowThreads(__tstate);
41149 if (PyErr_Occurred()) SWIG_fail;
41150 }
41151 {
41152 #if wxUSE_UNICODE
41153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41154 #else
41155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41156 #endif
41157 }
41158 return resultobj;
41159 fail:
41160 return NULL;
41161 }
41162
41163
41164 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41165 PyObject *resultobj = 0;
41166 wxMenu *arg1 = (wxMenu *) 0 ;
41167 wxString *arg2 = 0 ;
41168 void *argp1 = 0 ;
41169 int res1 = 0 ;
41170 bool temp2 = false ;
41171 PyObject * obj0 = 0 ;
41172 PyObject * obj1 = 0 ;
41173 char * kwnames[] = {
41174 (char *) "self",(char *) "title", NULL
41175 };
41176
41177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
41178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41179 if (!SWIG_IsOK(res1)) {
41180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
41181 }
41182 arg1 = reinterpret_cast< wxMenu * >(argp1);
41183 {
41184 arg2 = wxString_in_helper(obj1);
41185 if (arg2 == NULL) SWIG_fail;
41186 temp2 = true;
41187 }
41188 {
41189 PyThreadState* __tstate = wxPyBeginAllowThreads();
41190 (arg1)->SetTitle((wxString const &)*arg2);
41191 wxPyEndAllowThreads(__tstate);
41192 if (PyErr_Occurred()) SWIG_fail;
41193 }
41194 resultobj = SWIG_Py_Void();
41195 {
41196 if (temp2)
41197 delete arg2;
41198 }
41199 return resultobj;
41200 fail:
41201 {
41202 if (temp2)
41203 delete arg2;
41204 }
41205 return NULL;
41206 }
41207
41208
41209 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41210 PyObject *resultobj = 0;
41211 wxMenu *arg1 = (wxMenu *) 0 ;
41212 wxString result;
41213 void *argp1 = 0 ;
41214 int res1 = 0 ;
41215 PyObject *swig_obj[1] ;
41216
41217 if (!args) SWIG_fail;
41218 swig_obj[0] = args;
41219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41220 if (!SWIG_IsOK(res1)) {
41221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41222 }
41223 arg1 = reinterpret_cast< wxMenu * >(argp1);
41224 {
41225 PyThreadState* __tstate = wxPyBeginAllowThreads();
41226 result = ((wxMenu const *)arg1)->GetTitle();
41227 wxPyEndAllowThreads(__tstate);
41228 if (PyErr_Occurred()) SWIG_fail;
41229 }
41230 {
41231 #if wxUSE_UNICODE
41232 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41233 #else
41234 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41235 #endif
41236 }
41237 return resultobj;
41238 fail:
41239 return NULL;
41240 }
41241
41242
41243 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41244 PyObject *resultobj = 0;
41245 wxMenu *arg1 = (wxMenu *) 0 ;
41246 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
41247 void *argp1 = 0 ;
41248 int res1 = 0 ;
41249 void *argp2 = 0 ;
41250 int res2 = 0 ;
41251 PyObject * obj0 = 0 ;
41252 PyObject * obj1 = 0 ;
41253 char * kwnames[] = {
41254 (char *) "self",(char *) "handler", NULL
41255 };
41256
41257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
41258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41259 if (!SWIG_IsOK(res1)) {
41260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
41261 }
41262 arg1 = reinterpret_cast< wxMenu * >(argp1);
41263 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41264 if (!SWIG_IsOK(res2)) {
41265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41266 }
41267 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41268 {
41269 PyThreadState* __tstate = wxPyBeginAllowThreads();
41270 (arg1)->SetEventHandler(arg2);
41271 wxPyEndAllowThreads(__tstate);
41272 if (PyErr_Occurred()) SWIG_fail;
41273 }
41274 resultobj = SWIG_Py_Void();
41275 return resultobj;
41276 fail:
41277 return NULL;
41278 }
41279
41280
41281 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41282 PyObject *resultobj = 0;
41283 wxMenu *arg1 = (wxMenu *) 0 ;
41284 wxEvtHandler *result = 0 ;
41285 void *argp1 = 0 ;
41286 int res1 = 0 ;
41287 PyObject *swig_obj[1] ;
41288
41289 if (!args) SWIG_fail;
41290 swig_obj[0] = args;
41291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41292 if (!SWIG_IsOK(res1)) {
41293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
41294 }
41295 arg1 = reinterpret_cast< wxMenu * >(argp1);
41296 {
41297 PyThreadState* __tstate = wxPyBeginAllowThreads();
41298 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
41299 wxPyEndAllowThreads(__tstate);
41300 if (PyErr_Occurred()) SWIG_fail;
41301 }
41302 {
41303 resultobj = wxPyMake_wxObject(result, 0);
41304 }
41305 return resultobj;
41306 fail:
41307 return NULL;
41308 }
41309
41310
41311 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41312 PyObject *resultobj = 0;
41313 wxMenu *arg1 = (wxMenu *) 0 ;
41314 wxWindow *arg2 = (wxWindow *) 0 ;
41315 void *argp1 = 0 ;
41316 int res1 = 0 ;
41317 void *argp2 = 0 ;
41318 int res2 = 0 ;
41319 PyObject * obj0 = 0 ;
41320 PyObject * obj1 = 0 ;
41321 char * kwnames[] = {
41322 (char *) "self",(char *) "win", NULL
41323 };
41324
41325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41327 if (!SWIG_IsOK(res1)) {
41328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
41329 }
41330 arg1 = reinterpret_cast< wxMenu * >(argp1);
41331 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41332 if (!SWIG_IsOK(res2)) {
41333 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41334 }
41335 arg2 = reinterpret_cast< wxWindow * >(argp2);
41336 {
41337 PyThreadState* __tstate = wxPyBeginAllowThreads();
41338 (arg1)->SetInvokingWindow(arg2);
41339 wxPyEndAllowThreads(__tstate);
41340 if (PyErr_Occurred()) SWIG_fail;
41341 }
41342 resultobj = SWIG_Py_Void();
41343 return resultobj;
41344 fail:
41345 return NULL;
41346 }
41347
41348
41349 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41350 PyObject *resultobj = 0;
41351 wxMenu *arg1 = (wxMenu *) 0 ;
41352 wxWindow *result = 0 ;
41353 void *argp1 = 0 ;
41354 int res1 = 0 ;
41355 PyObject *swig_obj[1] ;
41356
41357 if (!args) SWIG_fail;
41358 swig_obj[0] = args;
41359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41360 if (!SWIG_IsOK(res1)) {
41361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
41362 }
41363 arg1 = reinterpret_cast< wxMenu * >(argp1);
41364 {
41365 PyThreadState* __tstate = wxPyBeginAllowThreads();
41366 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
41367 wxPyEndAllowThreads(__tstate);
41368 if (PyErr_Occurred()) SWIG_fail;
41369 }
41370 {
41371 resultobj = wxPyMake_wxObject(result, 0);
41372 }
41373 return resultobj;
41374 fail:
41375 return NULL;
41376 }
41377
41378
41379 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41380 PyObject *resultobj = 0;
41381 wxMenu *arg1 = (wxMenu *) 0 ;
41382 long result;
41383 void *argp1 = 0 ;
41384 int res1 = 0 ;
41385 PyObject *swig_obj[1] ;
41386
41387 if (!args) SWIG_fail;
41388 swig_obj[0] = args;
41389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41390 if (!SWIG_IsOK(res1)) {
41391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
41392 }
41393 arg1 = reinterpret_cast< wxMenu * >(argp1);
41394 {
41395 PyThreadState* __tstate = wxPyBeginAllowThreads();
41396 result = (long)((wxMenu const *)arg1)->GetStyle();
41397 wxPyEndAllowThreads(__tstate);
41398 if (PyErr_Occurred()) SWIG_fail;
41399 }
41400 resultobj = SWIG_From_long(static_cast< long >(result));
41401 return resultobj;
41402 fail:
41403 return NULL;
41404 }
41405
41406
41407 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41408 PyObject *resultobj = 0;
41409 wxMenu *arg1 = (wxMenu *) 0 ;
41410 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
41411 void *argp1 = 0 ;
41412 int res1 = 0 ;
41413 void *argp2 = 0 ;
41414 int res2 = 0 ;
41415 PyObject * obj0 = 0 ;
41416 PyObject * obj1 = 0 ;
41417 char * kwnames[] = {
41418 (char *) "self",(char *) "source", NULL
41419 };
41420
41421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
41422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41423 if (!SWIG_IsOK(res1)) {
41424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
41425 }
41426 arg1 = reinterpret_cast< wxMenu * >(argp1);
41427 if (obj1) {
41428 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
41429 if (!SWIG_IsOK(res2)) {
41430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
41431 }
41432 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
41433 }
41434 {
41435 PyThreadState* __tstate = wxPyBeginAllowThreads();
41436 (arg1)->UpdateUI(arg2);
41437 wxPyEndAllowThreads(__tstate);
41438 if (PyErr_Occurred()) SWIG_fail;
41439 }
41440 resultobj = SWIG_Py_Void();
41441 return resultobj;
41442 fail:
41443 return NULL;
41444 }
41445
41446
41447 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41448 PyObject *resultobj = 0;
41449 wxMenu *arg1 = (wxMenu *) 0 ;
41450 wxMenuBar *result = 0 ;
41451 void *argp1 = 0 ;
41452 int res1 = 0 ;
41453 PyObject *swig_obj[1] ;
41454
41455 if (!args) SWIG_fail;
41456 swig_obj[0] = args;
41457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41458 if (!SWIG_IsOK(res1)) {
41459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
41460 }
41461 arg1 = reinterpret_cast< wxMenu * >(argp1);
41462 {
41463 PyThreadState* __tstate = wxPyBeginAllowThreads();
41464 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
41465 wxPyEndAllowThreads(__tstate);
41466 if (PyErr_Occurred()) SWIG_fail;
41467 }
41468 {
41469 resultobj = wxPyMake_wxObject(result, (bool)0);
41470 }
41471 return resultobj;
41472 fail:
41473 return NULL;
41474 }
41475
41476
41477 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41478 PyObject *resultobj = 0;
41479 wxMenu *arg1 = (wxMenu *) 0 ;
41480 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
41481 void *argp1 = 0 ;
41482 int res1 = 0 ;
41483 void *argp2 = 0 ;
41484 int res2 = 0 ;
41485 PyObject * obj0 = 0 ;
41486 PyObject * obj1 = 0 ;
41487 char * kwnames[] = {
41488 (char *) "self",(char *) "menubar", NULL
41489 };
41490
41491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41493 if (!SWIG_IsOK(res1)) {
41494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
41495 }
41496 arg1 = reinterpret_cast< wxMenu * >(argp1);
41497 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
41498 if (!SWIG_IsOK(res2)) {
41499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
41500 }
41501 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
41502 {
41503 PyThreadState* __tstate = wxPyBeginAllowThreads();
41504 (arg1)->Attach(arg2);
41505 wxPyEndAllowThreads(__tstate);
41506 if (PyErr_Occurred()) SWIG_fail;
41507 }
41508 resultobj = SWIG_Py_Void();
41509 return resultobj;
41510 fail:
41511 return NULL;
41512 }
41513
41514
41515 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41516 PyObject *resultobj = 0;
41517 wxMenu *arg1 = (wxMenu *) 0 ;
41518 void *argp1 = 0 ;
41519 int res1 = 0 ;
41520 PyObject *swig_obj[1] ;
41521
41522 if (!args) SWIG_fail;
41523 swig_obj[0] = args;
41524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41525 if (!SWIG_IsOK(res1)) {
41526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
41527 }
41528 arg1 = reinterpret_cast< wxMenu * >(argp1);
41529 {
41530 PyThreadState* __tstate = wxPyBeginAllowThreads();
41531 (arg1)->Detach();
41532 wxPyEndAllowThreads(__tstate);
41533 if (PyErr_Occurred()) SWIG_fail;
41534 }
41535 resultobj = SWIG_Py_Void();
41536 return resultobj;
41537 fail:
41538 return NULL;
41539 }
41540
41541
41542 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41543 PyObject *resultobj = 0;
41544 wxMenu *arg1 = (wxMenu *) 0 ;
41545 bool result;
41546 void *argp1 = 0 ;
41547 int res1 = 0 ;
41548 PyObject *swig_obj[1] ;
41549
41550 if (!args) SWIG_fail;
41551 swig_obj[0] = args;
41552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41553 if (!SWIG_IsOK(res1)) {
41554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
41555 }
41556 arg1 = reinterpret_cast< wxMenu * >(argp1);
41557 {
41558 PyThreadState* __tstate = wxPyBeginAllowThreads();
41559 result = (bool)((wxMenu const *)arg1)->IsAttached();
41560 wxPyEndAllowThreads(__tstate);
41561 if (PyErr_Occurred()) SWIG_fail;
41562 }
41563 {
41564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41565 }
41566 return resultobj;
41567 fail:
41568 return NULL;
41569 }
41570
41571
41572 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41573 PyObject *resultobj = 0;
41574 wxMenu *arg1 = (wxMenu *) 0 ;
41575 wxMenu *arg2 = (wxMenu *) 0 ;
41576 void *argp1 = 0 ;
41577 int res1 = 0 ;
41578 void *argp2 = 0 ;
41579 int res2 = 0 ;
41580 PyObject * obj0 = 0 ;
41581 PyObject * obj1 = 0 ;
41582 char * kwnames[] = {
41583 (char *) "self",(char *) "parent", NULL
41584 };
41585
41586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
41587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41588 if (!SWIG_IsOK(res1)) {
41589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
41590 }
41591 arg1 = reinterpret_cast< wxMenu * >(argp1);
41592 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41593 if (!SWIG_IsOK(res2)) {
41594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
41595 }
41596 arg2 = reinterpret_cast< wxMenu * >(argp2);
41597 {
41598 PyThreadState* __tstate = wxPyBeginAllowThreads();
41599 (arg1)->SetParent(arg2);
41600 wxPyEndAllowThreads(__tstate);
41601 if (PyErr_Occurred()) SWIG_fail;
41602 }
41603 resultobj = SWIG_Py_Void();
41604 return resultobj;
41605 fail:
41606 return NULL;
41607 }
41608
41609
41610 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41611 PyObject *resultobj = 0;
41612 wxMenu *arg1 = (wxMenu *) 0 ;
41613 wxMenu *result = 0 ;
41614 void *argp1 = 0 ;
41615 int res1 = 0 ;
41616 PyObject *swig_obj[1] ;
41617
41618 if (!args) SWIG_fail;
41619 swig_obj[0] = args;
41620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41621 if (!SWIG_IsOK(res1)) {
41622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
41623 }
41624 arg1 = reinterpret_cast< wxMenu * >(argp1);
41625 {
41626 PyThreadState* __tstate = wxPyBeginAllowThreads();
41627 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
41628 wxPyEndAllowThreads(__tstate);
41629 if (PyErr_Occurred()) SWIG_fail;
41630 }
41631 {
41632 resultobj = wxPyMake_wxObject(result, 0);
41633 }
41634 return resultobj;
41635 fail:
41636 return NULL;
41637 }
41638
41639
41640 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41641 PyObject *obj;
41642 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41643 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
41644 return SWIG_Py_Void();
41645 }
41646
41647 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41648 return SWIG_Python_InitShadowInstance(args);
41649 }
41650
41651 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41652 PyObject *resultobj = 0;
41653 long arg1 = (long) 0 ;
41654 wxMenuBar *result = 0 ;
41655 long val1 ;
41656 int ecode1 = 0 ;
41657 PyObject * obj0 = 0 ;
41658 char * kwnames[] = {
41659 (char *) "style", NULL
41660 };
41661
41662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
41663 if (obj0) {
41664 ecode1 = SWIG_AsVal_long(obj0, &val1);
41665 if (!SWIG_IsOK(ecode1)) {
41666 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41667 }
41668 arg1 = static_cast< long >(val1);
41669 }
41670 {
41671 if (!wxPyCheckForApp()) SWIG_fail;
41672 PyThreadState* __tstate = wxPyBeginAllowThreads();
41673 result = (wxMenuBar *)new wxMenuBar(arg1);
41674 wxPyEndAllowThreads(__tstate);
41675 if (PyErr_Occurred()) SWIG_fail;
41676 }
41677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41678 return resultobj;
41679 fail:
41680 return NULL;
41681 }
41682
41683
41684 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41685 PyObject *resultobj = 0;
41686 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41687 wxMenu *arg2 = (wxMenu *) 0 ;
41688 wxString *arg3 = 0 ;
41689 bool result;
41690 void *argp1 = 0 ;
41691 int res1 = 0 ;
41692 void *argp2 = 0 ;
41693 int res2 = 0 ;
41694 bool temp3 = false ;
41695 PyObject * obj0 = 0 ;
41696 PyObject * obj1 = 0 ;
41697 PyObject * obj2 = 0 ;
41698 char * kwnames[] = {
41699 (char *) "self",(char *) "menu",(char *) "title", NULL
41700 };
41701
41702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41704 if (!SWIG_IsOK(res1)) {
41705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41706 }
41707 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41708 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41709 if (!SWIG_IsOK(res2)) {
41710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41711 }
41712 arg2 = reinterpret_cast< wxMenu * >(argp2);
41713 {
41714 arg3 = wxString_in_helper(obj2);
41715 if (arg3 == NULL) SWIG_fail;
41716 temp3 = true;
41717 }
41718 {
41719 PyThreadState* __tstate = wxPyBeginAllowThreads();
41720 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41721 wxPyEndAllowThreads(__tstate);
41722 if (PyErr_Occurred()) SWIG_fail;
41723 }
41724 {
41725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41726 }
41727 {
41728 if (temp3)
41729 delete arg3;
41730 }
41731 return resultobj;
41732 fail:
41733 {
41734 if (temp3)
41735 delete arg3;
41736 }
41737 return NULL;
41738 }
41739
41740
41741 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41742 PyObject *resultobj = 0;
41743 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41744 size_t arg2 ;
41745 wxMenu *arg3 = (wxMenu *) 0 ;
41746 wxString *arg4 = 0 ;
41747 bool result;
41748 void *argp1 = 0 ;
41749 int res1 = 0 ;
41750 size_t val2 ;
41751 int ecode2 = 0 ;
41752 void *argp3 = 0 ;
41753 int res3 = 0 ;
41754 bool temp4 = false ;
41755 PyObject * obj0 = 0 ;
41756 PyObject * obj1 = 0 ;
41757 PyObject * obj2 = 0 ;
41758 PyObject * obj3 = 0 ;
41759 char * kwnames[] = {
41760 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41761 };
41762
41763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41765 if (!SWIG_IsOK(res1)) {
41766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41767 }
41768 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41769 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41770 if (!SWIG_IsOK(ecode2)) {
41771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41772 }
41773 arg2 = static_cast< size_t >(val2);
41774 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41775 if (!SWIG_IsOK(res3)) {
41776 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41777 }
41778 arg3 = reinterpret_cast< wxMenu * >(argp3);
41779 {
41780 arg4 = wxString_in_helper(obj3);
41781 if (arg4 == NULL) SWIG_fail;
41782 temp4 = true;
41783 }
41784 {
41785 PyThreadState* __tstate = wxPyBeginAllowThreads();
41786 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41787 wxPyEndAllowThreads(__tstate);
41788 if (PyErr_Occurred()) SWIG_fail;
41789 }
41790 {
41791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41792 }
41793 {
41794 if (temp4)
41795 delete arg4;
41796 }
41797 return resultobj;
41798 fail:
41799 {
41800 if (temp4)
41801 delete arg4;
41802 }
41803 return NULL;
41804 }
41805
41806
41807 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41808 PyObject *resultobj = 0;
41809 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41810 size_t result;
41811 void *argp1 = 0 ;
41812 int res1 = 0 ;
41813 PyObject *swig_obj[1] ;
41814
41815 if (!args) SWIG_fail;
41816 swig_obj[0] = args;
41817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41818 if (!SWIG_IsOK(res1)) {
41819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41820 }
41821 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41822 {
41823 PyThreadState* __tstate = wxPyBeginAllowThreads();
41824 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41825 wxPyEndAllowThreads(__tstate);
41826 if (PyErr_Occurred()) SWIG_fail;
41827 }
41828 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41829 return resultobj;
41830 fail:
41831 return NULL;
41832 }
41833
41834
41835 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41836 PyObject *resultobj = 0;
41837 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41838 size_t arg2 ;
41839 wxMenu *result = 0 ;
41840 void *argp1 = 0 ;
41841 int res1 = 0 ;
41842 size_t val2 ;
41843 int ecode2 = 0 ;
41844 PyObject * obj0 = 0 ;
41845 PyObject * obj1 = 0 ;
41846 char * kwnames[] = {
41847 (char *) "self",(char *) "pos", NULL
41848 };
41849
41850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41852 if (!SWIG_IsOK(res1)) {
41853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41854 }
41855 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41856 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41857 if (!SWIG_IsOK(ecode2)) {
41858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41859 }
41860 arg2 = static_cast< size_t >(val2);
41861 {
41862 PyThreadState* __tstate = wxPyBeginAllowThreads();
41863 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41864 wxPyEndAllowThreads(__tstate);
41865 if (PyErr_Occurred()) SWIG_fail;
41866 }
41867 {
41868 resultobj = wxPyMake_wxObject(result, 0);
41869 }
41870 return resultobj;
41871 fail:
41872 return NULL;
41873 }
41874
41875
41876 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41877 PyObject *resultobj = 0;
41878 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41879 size_t arg2 ;
41880 wxMenu *arg3 = (wxMenu *) 0 ;
41881 wxString *arg4 = 0 ;
41882 wxMenu *result = 0 ;
41883 void *argp1 = 0 ;
41884 int res1 = 0 ;
41885 size_t val2 ;
41886 int ecode2 = 0 ;
41887 void *argp3 = 0 ;
41888 int res3 = 0 ;
41889 bool temp4 = false ;
41890 PyObject * obj0 = 0 ;
41891 PyObject * obj1 = 0 ;
41892 PyObject * obj2 = 0 ;
41893 PyObject * obj3 = 0 ;
41894 char * kwnames[] = {
41895 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41896 };
41897
41898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41900 if (!SWIG_IsOK(res1)) {
41901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41902 }
41903 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41904 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41905 if (!SWIG_IsOK(ecode2)) {
41906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41907 }
41908 arg2 = static_cast< size_t >(val2);
41909 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41910 if (!SWIG_IsOK(res3)) {
41911 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41912 }
41913 arg3 = reinterpret_cast< wxMenu * >(argp3);
41914 {
41915 arg4 = wxString_in_helper(obj3);
41916 if (arg4 == NULL) SWIG_fail;
41917 temp4 = true;
41918 }
41919 {
41920 PyThreadState* __tstate = wxPyBeginAllowThreads();
41921 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41922 wxPyEndAllowThreads(__tstate);
41923 if (PyErr_Occurred()) SWIG_fail;
41924 }
41925 {
41926 resultobj = wxPyMake_wxObject(result, 0);
41927 }
41928 {
41929 if (temp4)
41930 delete arg4;
41931 }
41932 return resultobj;
41933 fail:
41934 {
41935 if (temp4)
41936 delete arg4;
41937 }
41938 return NULL;
41939 }
41940
41941
41942 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41943 PyObject *resultobj = 0;
41944 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41945 size_t arg2 ;
41946 wxMenu *result = 0 ;
41947 void *argp1 = 0 ;
41948 int res1 = 0 ;
41949 size_t val2 ;
41950 int ecode2 = 0 ;
41951 PyObject * obj0 = 0 ;
41952 PyObject * obj1 = 0 ;
41953 char * kwnames[] = {
41954 (char *) "self",(char *) "pos", NULL
41955 };
41956
41957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41959 if (!SWIG_IsOK(res1)) {
41960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41961 }
41962 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41963 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41964 if (!SWIG_IsOK(ecode2)) {
41965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41966 }
41967 arg2 = static_cast< size_t >(val2);
41968 {
41969 PyThreadState* __tstate = wxPyBeginAllowThreads();
41970 result = (wxMenu *)(arg1)->Remove(arg2);
41971 wxPyEndAllowThreads(__tstate);
41972 if (PyErr_Occurred()) SWIG_fail;
41973 }
41974 {
41975 resultobj = wxPyMake_wxObject(result, 0);
41976 }
41977 return resultobj;
41978 fail:
41979 return NULL;
41980 }
41981
41982
41983 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41984 PyObject *resultobj = 0;
41985 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41986 size_t arg2 ;
41987 bool arg3 ;
41988 void *argp1 = 0 ;
41989 int res1 = 0 ;
41990 size_t val2 ;
41991 int ecode2 = 0 ;
41992 bool val3 ;
41993 int ecode3 = 0 ;
41994 PyObject * obj0 = 0 ;
41995 PyObject * obj1 = 0 ;
41996 PyObject * obj2 = 0 ;
41997 char * kwnames[] = {
41998 (char *) "self",(char *) "pos",(char *) "enable", NULL
41999 };
42000
42001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42003 if (!SWIG_IsOK(res1)) {
42004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42005 }
42006 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42007 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42008 if (!SWIG_IsOK(ecode2)) {
42009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
42010 }
42011 arg2 = static_cast< size_t >(val2);
42012 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42013 if (!SWIG_IsOK(ecode3)) {
42014 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
42015 }
42016 arg3 = static_cast< bool >(val3);
42017 {
42018 PyThreadState* __tstate = wxPyBeginAllowThreads();
42019 (arg1)->EnableTop(arg2,arg3);
42020 wxPyEndAllowThreads(__tstate);
42021 if (PyErr_Occurred()) SWIG_fail;
42022 }
42023 resultobj = SWIG_Py_Void();
42024 return resultobj;
42025 fail:
42026 return NULL;
42027 }
42028
42029
42030 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42031 PyObject *resultobj = 0;
42032 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42033 size_t arg2 ;
42034 bool result;
42035 void *argp1 = 0 ;
42036 int res1 = 0 ;
42037 size_t val2 ;
42038 int ecode2 = 0 ;
42039 PyObject * obj0 = 0 ;
42040 PyObject * obj1 = 0 ;
42041 char * kwnames[] = {
42042 (char *) "self",(char *) "pos", NULL
42043 };
42044
42045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
42046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42047 if (!SWIG_IsOK(res1)) {
42048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42049 }
42050 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42051 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42052 if (!SWIG_IsOK(ecode2)) {
42053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
42054 }
42055 arg2 = static_cast< size_t >(val2);
42056 {
42057 PyThreadState* __tstate = wxPyBeginAllowThreads();
42058 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
42059 wxPyEndAllowThreads(__tstate);
42060 if (PyErr_Occurred()) SWIG_fail;
42061 }
42062 {
42063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42064 }
42065 return resultobj;
42066 fail:
42067 return NULL;
42068 }
42069
42070
42071 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42072 PyObject *resultobj = 0;
42073 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42074 size_t arg2 ;
42075 wxString *arg3 = 0 ;
42076 void *argp1 = 0 ;
42077 int res1 = 0 ;
42078 size_t val2 ;
42079 int ecode2 = 0 ;
42080 bool temp3 = false ;
42081 PyObject * obj0 = 0 ;
42082 PyObject * obj1 = 0 ;
42083 PyObject * obj2 = 0 ;
42084 char * kwnames[] = {
42085 (char *) "self",(char *) "pos",(char *) "label", NULL
42086 };
42087
42088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42090 if (!SWIG_IsOK(res1)) {
42091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42092 }
42093 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42094 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42095 if (!SWIG_IsOK(ecode2)) {
42096 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42097 }
42098 arg2 = static_cast< size_t >(val2);
42099 {
42100 arg3 = wxString_in_helper(obj2);
42101 if (arg3 == NULL) SWIG_fail;
42102 temp3 = true;
42103 }
42104 {
42105 PyThreadState* __tstate = wxPyBeginAllowThreads();
42106 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
42107 wxPyEndAllowThreads(__tstate);
42108 if (PyErr_Occurred()) SWIG_fail;
42109 }
42110 resultobj = SWIG_Py_Void();
42111 {
42112 if (temp3)
42113 delete arg3;
42114 }
42115 return resultobj;
42116 fail:
42117 {
42118 if (temp3)
42119 delete arg3;
42120 }
42121 return NULL;
42122 }
42123
42124
42125 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42126 PyObject *resultobj = 0;
42127 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42128 size_t arg2 ;
42129 wxString result;
42130 void *argp1 = 0 ;
42131 int res1 = 0 ;
42132 size_t val2 ;
42133 int ecode2 = 0 ;
42134 PyObject * obj0 = 0 ;
42135 PyObject * obj1 = 0 ;
42136 char * kwnames[] = {
42137 (char *) "self",(char *) "pos", NULL
42138 };
42139
42140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
42141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42142 if (!SWIG_IsOK(res1)) {
42143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42144 }
42145 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42146 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42147 if (!SWIG_IsOK(ecode2)) {
42148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
42149 }
42150 arg2 = static_cast< size_t >(val2);
42151 {
42152 PyThreadState* __tstate = wxPyBeginAllowThreads();
42153 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
42154 wxPyEndAllowThreads(__tstate);
42155 if (PyErr_Occurred()) SWIG_fail;
42156 }
42157 {
42158 #if wxUSE_UNICODE
42159 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42160 #else
42161 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42162 #endif
42163 }
42164 return resultobj;
42165 fail:
42166 return NULL;
42167 }
42168
42169
42170 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42171 PyObject *resultobj = 0;
42172 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42173 wxString *arg2 = 0 ;
42174 wxString *arg3 = 0 ;
42175 int result;
42176 void *argp1 = 0 ;
42177 int res1 = 0 ;
42178 bool temp2 = false ;
42179 bool temp3 = false ;
42180 PyObject * obj0 = 0 ;
42181 PyObject * obj1 = 0 ;
42182 PyObject * obj2 = 0 ;
42183 char * kwnames[] = {
42184 (char *) "self",(char *) "menu",(char *) "item", NULL
42185 };
42186
42187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) 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_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42191 }
42192 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42193 {
42194 arg2 = wxString_in_helper(obj1);
42195 if (arg2 == NULL) SWIG_fail;
42196 temp2 = true;
42197 }
42198 {
42199 arg3 = wxString_in_helper(obj2);
42200 if (arg3 == NULL) SWIG_fail;
42201 temp3 = true;
42202 }
42203 {
42204 PyThreadState* __tstate = wxPyBeginAllowThreads();
42205 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
42206 wxPyEndAllowThreads(__tstate);
42207 if (PyErr_Occurred()) SWIG_fail;
42208 }
42209 resultobj = SWIG_From_int(static_cast< int >(result));
42210 {
42211 if (temp2)
42212 delete arg2;
42213 }
42214 {
42215 if (temp3)
42216 delete arg3;
42217 }
42218 return resultobj;
42219 fail:
42220 {
42221 if (temp2)
42222 delete arg2;
42223 }
42224 {
42225 if (temp3)
42226 delete arg3;
42227 }
42228 return NULL;
42229 }
42230
42231
42232 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42233 PyObject *resultobj = 0;
42234 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42235 int arg2 ;
42236 wxMenuItem *result = 0 ;
42237 void *argp1 = 0 ;
42238 int res1 = 0 ;
42239 int val2 ;
42240 int ecode2 = 0 ;
42241 PyObject * obj0 = 0 ;
42242 PyObject * obj1 = 0 ;
42243 char * kwnames[] = {
42244 (char *) "self",(char *) "id", NULL
42245 };
42246
42247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
42248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42249 if (!SWIG_IsOK(res1)) {
42250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42251 }
42252 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42253 ecode2 = SWIG_AsVal_int(obj1, &val2);
42254 if (!SWIG_IsOK(ecode2)) {
42255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
42256 }
42257 arg2 = static_cast< int >(val2);
42258 {
42259 PyThreadState* __tstate = wxPyBeginAllowThreads();
42260 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
42261 wxPyEndAllowThreads(__tstate);
42262 if (PyErr_Occurred()) SWIG_fail;
42263 }
42264 {
42265 resultobj = wxPyMake_wxObject(result, (bool)0);
42266 }
42267 return resultobj;
42268 fail:
42269 return NULL;
42270 }
42271
42272
42273 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42274 PyObject *resultobj = 0;
42275 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42276 wxString *arg2 = 0 ;
42277 int result;
42278 void *argp1 = 0 ;
42279 int res1 = 0 ;
42280 bool temp2 = false ;
42281 PyObject * obj0 = 0 ;
42282 PyObject * obj1 = 0 ;
42283 char * kwnames[] = {
42284 (char *) "self",(char *) "title", NULL
42285 };
42286
42287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42289 if (!SWIG_IsOK(res1)) {
42290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42291 }
42292 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42293 {
42294 arg2 = wxString_in_helper(obj1);
42295 if (arg2 == NULL) SWIG_fail;
42296 temp2 = true;
42297 }
42298 {
42299 PyThreadState* __tstate = wxPyBeginAllowThreads();
42300 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
42301 wxPyEndAllowThreads(__tstate);
42302 if (PyErr_Occurred()) SWIG_fail;
42303 }
42304 resultobj = SWIG_From_int(static_cast< int >(result));
42305 {
42306 if (temp2)
42307 delete arg2;
42308 }
42309 return resultobj;
42310 fail:
42311 {
42312 if (temp2)
42313 delete arg2;
42314 }
42315 return NULL;
42316 }
42317
42318
42319 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42320 PyObject *resultobj = 0;
42321 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42322 int arg2 ;
42323 bool arg3 ;
42324 void *argp1 = 0 ;
42325 int res1 = 0 ;
42326 int val2 ;
42327 int ecode2 = 0 ;
42328 bool val3 ;
42329 int ecode3 = 0 ;
42330 PyObject * obj0 = 0 ;
42331 PyObject * obj1 = 0 ;
42332 PyObject * obj2 = 0 ;
42333 char * kwnames[] = {
42334 (char *) "self",(char *) "id",(char *) "enable", NULL
42335 };
42336
42337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42339 if (!SWIG_IsOK(res1)) {
42340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42341 }
42342 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42343 ecode2 = SWIG_AsVal_int(obj1, &val2);
42344 if (!SWIG_IsOK(ecode2)) {
42345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
42346 }
42347 arg2 = static_cast< int >(val2);
42348 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42349 if (!SWIG_IsOK(ecode3)) {
42350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
42351 }
42352 arg3 = static_cast< bool >(val3);
42353 {
42354 PyThreadState* __tstate = wxPyBeginAllowThreads();
42355 (arg1)->Enable(arg2,arg3);
42356 wxPyEndAllowThreads(__tstate);
42357 if (PyErr_Occurred()) SWIG_fail;
42358 }
42359 resultobj = SWIG_Py_Void();
42360 return resultobj;
42361 fail:
42362 return NULL;
42363 }
42364
42365
42366 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42367 PyObject *resultobj = 0;
42368 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42369 int arg2 ;
42370 bool arg3 ;
42371 void *argp1 = 0 ;
42372 int res1 = 0 ;
42373 int val2 ;
42374 int ecode2 = 0 ;
42375 bool val3 ;
42376 int ecode3 = 0 ;
42377 PyObject * obj0 = 0 ;
42378 PyObject * obj1 = 0 ;
42379 PyObject * obj2 = 0 ;
42380 char * kwnames[] = {
42381 (char *) "self",(char *) "id",(char *) "check", NULL
42382 };
42383
42384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42386 if (!SWIG_IsOK(res1)) {
42387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42388 }
42389 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42390 ecode2 = SWIG_AsVal_int(obj1, &val2);
42391 if (!SWIG_IsOK(ecode2)) {
42392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
42393 }
42394 arg2 = static_cast< int >(val2);
42395 ecode3 = SWIG_AsVal_bool(obj2, &val3);
42396 if (!SWIG_IsOK(ecode3)) {
42397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
42398 }
42399 arg3 = static_cast< bool >(val3);
42400 {
42401 PyThreadState* __tstate = wxPyBeginAllowThreads();
42402 (arg1)->Check(arg2,arg3);
42403 wxPyEndAllowThreads(__tstate);
42404 if (PyErr_Occurred()) SWIG_fail;
42405 }
42406 resultobj = SWIG_Py_Void();
42407 return resultobj;
42408 fail:
42409 return NULL;
42410 }
42411
42412
42413 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42414 PyObject *resultobj = 0;
42415 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42416 int arg2 ;
42417 bool result;
42418 void *argp1 = 0 ;
42419 int res1 = 0 ;
42420 int val2 ;
42421 int ecode2 = 0 ;
42422 PyObject * obj0 = 0 ;
42423 PyObject * obj1 = 0 ;
42424 char * kwnames[] = {
42425 (char *) "self",(char *) "id", NULL
42426 };
42427
42428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
42429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42430 if (!SWIG_IsOK(res1)) {
42431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42432 }
42433 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42434 ecode2 = SWIG_AsVal_int(obj1, &val2);
42435 if (!SWIG_IsOK(ecode2)) {
42436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
42437 }
42438 arg2 = static_cast< int >(val2);
42439 {
42440 PyThreadState* __tstate = wxPyBeginAllowThreads();
42441 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
42442 wxPyEndAllowThreads(__tstate);
42443 if (PyErr_Occurred()) SWIG_fail;
42444 }
42445 {
42446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42447 }
42448 return resultobj;
42449 fail:
42450 return NULL;
42451 }
42452
42453
42454 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42455 PyObject *resultobj = 0;
42456 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42457 int arg2 ;
42458 bool result;
42459 void *argp1 = 0 ;
42460 int res1 = 0 ;
42461 int val2 ;
42462 int ecode2 = 0 ;
42463 PyObject * obj0 = 0 ;
42464 PyObject * obj1 = 0 ;
42465 char * kwnames[] = {
42466 (char *) "self",(char *) "id", NULL
42467 };
42468
42469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
42470 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42471 if (!SWIG_IsOK(res1)) {
42472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42473 }
42474 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42475 ecode2 = SWIG_AsVal_int(obj1, &val2);
42476 if (!SWIG_IsOK(ecode2)) {
42477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
42478 }
42479 arg2 = static_cast< int >(val2);
42480 {
42481 PyThreadState* __tstate = wxPyBeginAllowThreads();
42482 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
42483 wxPyEndAllowThreads(__tstate);
42484 if (PyErr_Occurred()) SWIG_fail;
42485 }
42486 {
42487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42488 }
42489 return resultobj;
42490 fail:
42491 return NULL;
42492 }
42493
42494
42495 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42496 PyObject *resultobj = 0;
42497 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42498 int arg2 ;
42499 wxString *arg3 = 0 ;
42500 void *argp1 = 0 ;
42501 int res1 = 0 ;
42502 int val2 ;
42503 int ecode2 = 0 ;
42504 bool temp3 = false ;
42505 PyObject * obj0 = 0 ;
42506 PyObject * obj1 = 0 ;
42507 PyObject * obj2 = 0 ;
42508 char * kwnames[] = {
42509 (char *) "self",(char *) "id",(char *) "label", NULL
42510 };
42511
42512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42514 if (!SWIG_IsOK(res1)) {
42515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42516 }
42517 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42518 ecode2 = SWIG_AsVal_int(obj1, &val2);
42519 if (!SWIG_IsOK(ecode2)) {
42520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
42521 }
42522 arg2 = static_cast< int >(val2);
42523 {
42524 arg3 = wxString_in_helper(obj2);
42525 if (arg3 == NULL) SWIG_fail;
42526 temp3 = true;
42527 }
42528 {
42529 PyThreadState* __tstate = wxPyBeginAllowThreads();
42530 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
42531 wxPyEndAllowThreads(__tstate);
42532 if (PyErr_Occurred()) SWIG_fail;
42533 }
42534 resultobj = SWIG_Py_Void();
42535 {
42536 if (temp3)
42537 delete arg3;
42538 }
42539 return resultobj;
42540 fail:
42541 {
42542 if (temp3)
42543 delete arg3;
42544 }
42545 return NULL;
42546 }
42547
42548
42549 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42550 PyObject *resultobj = 0;
42551 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42552 int arg2 ;
42553 wxString result;
42554 void *argp1 = 0 ;
42555 int res1 = 0 ;
42556 int val2 ;
42557 int ecode2 = 0 ;
42558 PyObject * obj0 = 0 ;
42559 PyObject * obj1 = 0 ;
42560 char * kwnames[] = {
42561 (char *) "self",(char *) "id", NULL
42562 };
42563
42564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42566 if (!SWIG_IsOK(res1)) {
42567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42568 }
42569 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42570 ecode2 = SWIG_AsVal_int(obj1, &val2);
42571 if (!SWIG_IsOK(ecode2)) {
42572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
42573 }
42574 arg2 = static_cast< int >(val2);
42575 {
42576 PyThreadState* __tstate = wxPyBeginAllowThreads();
42577 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
42578 wxPyEndAllowThreads(__tstate);
42579 if (PyErr_Occurred()) SWIG_fail;
42580 }
42581 {
42582 #if wxUSE_UNICODE
42583 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42584 #else
42585 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42586 #endif
42587 }
42588 return resultobj;
42589 fail:
42590 return NULL;
42591 }
42592
42593
42594 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42595 PyObject *resultobj = 0;
42596 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42597 int arg2 ;
42598 wxString *arg3 = 0 ;
42599 void *argp1 = 0 ;
42600 int res1 = 0 ;
42601 int val2 ;
42602 int ecode2 = 0 ;
42603 bool temp3 = false ;
42604 PyObject * obj0 = 0 ;
42605 PyObject * obj1 = 0 ;
42606 PyObject * obj2 = 0 ;
42607 char * kwnames[] = {
42608 (char *) "self",(char *) "id",(char *) "helpString", NULL
42609 };
42610
42611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42613 if (!SWIG_IsOK(res1)) {
42614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42615 }
42616 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42617 ecode2 = SWIG_AsVal_int(obj1, &val2);
42618 if (!SWIG_IsOK(ecode2)) {
42619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
42620 }
42621 arg2 = static_cast< int >(val2);
42622 {
42623 arg3 = wxString_in_helper(obj2);
42624 if (arg3 == NULL) SWIG_fail;
42625 temp3 = true;
42626 }
42627 {
42628 PyThreadState* __tstate = wxPyBeginAllowThreads();
42629 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
42630 wxPyEndAllowThreads(__tstate);
42631 if (PyErr_Occurred()) SWIG_fail;
42632 }
42633 resultobj = SWIG_Py_Void();
42634 {
42635 if (temp3)
42636 delete arg3;
42637 }
42638 return resultobj;
42639 fail:
42640 {
42641 if (temp3)
42642 delete arg3;
42643 }
42644 return NULL;
42645 }
42646
42647
42648 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42649 PyObject *resultobj = 0;
42650 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42651 int arg2 ;
42652 wxString result;
42653 void *argp1 = 0 ;
42654 int res1 = 0 ;
42655 int val2 ;
42656 int ecode2 = 0 ;
42657 PyObject * obj0 = 0 ;
42658 PyObject * obj1 = 0 ;
42659 char * kwnames[] = {
42660 (char *) "self",(char *) "id", NULL
42661 };
42662
42663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
42664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42665 if (!SWIG_IsOK(res1)) {
42666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42667 }
42668 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42669 ecode2 = SWIG_AsVal_int(obj1, &val2);
42670 if (!SWIG_IsOK(ecode2)) {
42671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42672 }
42673 arg2 = static_cast< int >(val2);
42674 {
42675 PyThreadState* __tstate = wxPyBeginAllowThreads();
42676 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42677 wxPyEndAllowThreads(__tstate);
42678 if (PyErr_Occurred()) SWIG_fail;
42679 }
42680 {
42681 #if wxUSE_UNICODE
42682 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42683 #else
42684 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42685 #endif
42686 }
42687 return resultobj;
42688 fail:
42689 return NULL;
42690 }
42691
42692
42693 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42694 PyObject *resultobj = 0;
42695 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42696 wxFrame *result = 0 ;
42697 void *argp1 = 0 ;
42698 int res1 = 0 ;
42699 PyObject *swig_obj[1] ;
42700
42701 if (!args) SWIG_fail;
42702 swig_obj[0] = args;
42703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42704 if (!SWIG_IsOK(res1)) {
42705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42706 }
42707 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42708 {
42709 PyThreadState* __tstate = wxPyBeginAllowThreads();
42710 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42711 wxPyEndAllowThreads(__tstate);
42712 if (PyErr_Occurred()) SWIG_fail;
42713 }
42714 {
42715 resultobj = wxPyMake_wxObject(result, (bool)0);
42716 }
42717 return resultobj;
42718 fail:
42719 return NULL;
42720 }
42721
42722
42723 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42724 PyObject *resultobj = 0;
42725 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42726 bool result;
42727 void *argp1 = 0 ;
42728 int res1 = 0 ;
42729 PyObject *swig_obj[1] ;
42730
42731 if (!args) SWIG_fail;
42732 swig_obj[0] = args;
42733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42734 if (!SWIG_IsOK(res1)) {
42735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42736 }
42737 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42738 {
42739 PyThreadState* __tstate = wxPyBeginAllowThreads();
42740 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42741 wxPyEndAllowThreads(__tstate);
42742 if (PyErr_Occurred()) SWIG_fail;
42743 }
42744 {
42745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42746 }
42747 return resultobj;
42748 fail:
42749 return NULL;
42750 }
42751
42752
42753 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42754 PyObject *resultobj = 0;
42755 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42756 wxFrame *arg2 = (wxFrame *) 0 ;
42757 void *argp1 = 0 ;
42758 int res1 = 0 ;
42759 void *argp2 = 0 ;
42760 int res2 = 0 ;
42761 PyObject * obj0 = 0 ;
42762 PyObject * obj1 = 0 ;
42763 char * kwnames[] = {
42764 (char *) "self",(char *) "frame", NULL
42765 };
42766
42767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42769 if (!SWIG_IsOK(res1)) {
42770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42771 }
42772 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42774 if (!SWIG_IsOK(res2)) {
42775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42776 }
42777 arg2 = reinterpret_cast< wxFrame * >(argp2);
42778 {
42779 PyThreadState* __tstate = wxPyBeginAllowThreads();
42780 (arg1)->Attach(arg2);
42781 wxPyEndAllowThreads(__tstate);
42782 if (PyErr_Occurred()) SWIG_fail;
42783 }
42784 resultobj = SWIG_Py_Void();
42785 return resultobj;
42786 fail:
42787 return NULL;
42788 }
42789
42790
42791 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42792 PyObject *resultobj = 0;
42793 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42794 void *argp1 = 0 ;
42795 int res1 = 0 ;
42796 PyObject *swig_obj[1] ;
42797
42798 if (!args) SWIG_fail;
42799 swig_obj[0] = args;
42800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42801 if (!SWIG_IsOK(res1)) {
42802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42803 }
42804 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42805 {
42806 PyThreadState* __tstate = wxPyBeginAllowThreads();
42807 (arg1)->Detach();
42808 wxPyEndAllowThreads(__tstate);
42809 if (PyErr_Occurred()) SWIG_fail;
42810 }
42811 resultobj = SWIG_Py_Void();
42812 return resultobj;
42813 fail:
42814 return NULL;
42815 }
42816
42817
42818 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42819 PyObject *resultobj = 0;
42820 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42821 void *argp1 = 0 ;
42822 int res1 = 0 ;
42823 PyObject *swig_obj[1] ;
42824
42825 if (!args) SWIG_fail;
42826 swig_obj[0] = args;
42827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42828 if (!SWIG_IsOK(res1)) {
42829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42830 }
42831 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42832 {
42833 PyThreadState* __tstate = wxPyBeginAllowThreads();
42834 (arg1)->UpdateMenus();
42835 wxPyEndAllowThreads(__tstate);
42836 if (PyErr_Occurred()) SWIG_fail;
42837 }
42838 resultobj = SWIG_Py_Void();
42839 return resultobj;
42840 fail:
42841 return NULL;
42842 }
42843
42844
42845 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42846 PyObject *resultobj = 0;
42847 bool arg1 ;
42848 bool val1 ;
42849 int ecode1 = 0 ;
42850 PyObject * obj0 = 0 ;
42851 char * kwnames[] = {
42852 (char *) "enable", NULL
42853 };
42854
42855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42856 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42857 if (!SWIG_IsOK(ecode1)) {
42858 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42859 }
42860 arg1 = static_cast< bool >(val1);
42861 {
42862 PyThreadState* __tstate = wxPyBeginAllowThreads();
42863 wxMenuBar_SetAutoWindowMenu(arg1);
42864 wxPyEndAllowThreads(__tstate);
42865 if (PyErr_Occurred()) SWIG_fail;
42866 }
42867 resultobj = SWIG_Py_Void();
42868 return resultobj;
42869 fail:
42870 return NULL;
42871 }
42872
42873
42874 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42875 PyObject *resultobj = 0;
42876 bool result;
42877
42878 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42879 {
42880 PyThreadState* __tstate = wxPyBeginAllowThreads();
42881 result = (bool)wxMenuBar_GetAutoWindowMenu();
42882 wxPyEndAllowThreads(__tstate);
42883 if (PyErr_Occurred()) SWIG_fail;
42884 }
42885 {
42886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42887 }
42888 return resultobj;
42889 fail:
42890 return NULL;
42891 }
42892
42893
42894 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42895 PyObject *obj;
42896 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42897 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42898 return SWIG_Py_Void();
42899 }
42900
42901 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42902 return SWIG_Python_InitShadowInstance(args);
42903 }
42904
42905 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42906 PyObject *resultobj = 0;
42907 wxMenu *arg1 = (wxMenu *) NULL ;
42908 int arg2 = (int) wxID_ANY ;
42909 wxString const &arg3_defvalue = wxPyEmptyString ;
42910 wxString *arg3 = (wxString *) &arg3_defvalue ;
42911 wxString const &arg4_defvalue = wxPyEmptyString ;
42912 wxString *arg4 = (wxString *) &arg4_defvalue ;
42913 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42914 wxMenu *arg6 = (wxMenu *) NULL ;
42915 wxMenuItem *result = 0 ;
42916 void *argp1 = 0 ;
42917 int res1 = 0 ;
42918 int val2 ;
42919 int ecode2 = 0 ;
42920 bool temp3 = false ;
42921 bool temp4 = false ;
42922 int val5 ;
42923 int ecode5 = 0 ;
42924 void *argp6 = 0 ;
42925 int res6 = 0 ;
42926 PyObject * obj0 = 0 ;
42927 PyObject * obj1 = 0 ;
42928 PyObject * obj2 = 0 ;
42929 PyObject * obj3 = 0 ;
42930 PyObject * obj4 = 0 ;
42931 PyObject * obj5 = 0 ;
42932 char * kwnames[] = {
42933 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42934 };
42935
42936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42937 if (obj0) {
42938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42939 if (!SWIG_IsOK(res1)) {
42940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42941 }
42942 arg1 = reinterpret_cast< wxMenu * >(argp1);
42943 }
42944 if (obj1) {
42945 ecode2 = SWIG_AsVal_int(obj1, &val2);
42946 if (!SWIG_IsOK(ecode2)) {
42947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42948 }
42949 arg2 = static_cast< int >(val2);
42950 }
42951 if (obj2) {
42952 {
42953 arg3 = wxString_in_helper(obj2);
42954 if (arg3 == NULL) SWIG_fail;
42955 temp3 = true;
42956 }
42957 }
42958 if (obj3) {
42959 {
42960 arg4 = wxString_in_helper(obj3);
42961 if (arg4 == NULL) SWIG_fail;
42962 temp4 = true;
42963 }
42964 }
42965 if (obj4) {
42966 ecode5 = SWIG_AsVal_int(obj4, &val5);
42967 if (!SWIG_IsOK(ecode5)) {
42968 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42969 }
42970 arg5 = static_cast< wxItemKind >(val5);
42971 }
42972 if (obj5) {
42973 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42974 if (!SWIG_IsOK(res6)) {
42975 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42976 }
42977 arg6 = reinterpret_cast< wxMenu * >(argp6);
42978 }
42979 {
42980 PyThreadState* __tstate = wxPyBeginAllowThreads();
42981 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42982 wxPyEndAllowThreads(__tstate);
42983 if (PyErr_Occurred()) SWIG_fail;
42984 }
42985 {
42986 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42987 }
42988 {
42989 if (temp3)
42990 delete arg3;
42991 }
42992 {
42993 if (temp4)
42994 delete arg4;
42995 }
42996 return resultobj;
42997 fail:
42998 {
42999 if (temp3)
43000 delete arg3;
43001 }
43002 {
43003 if (temp4)
43004 delete arg4;
43005 }
43006 return NULL;
43007 }
43008
43009
43010 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43011 PyObject *resultobj = 0;
43012 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43013 void *argp1 = 0 ;
43014 int res1 = 0 ;
43015 PyObject *swig_obj[1] ;
43016
43017 if (!args) SWIG_fail;
43018 swig_obj[0] = args;
43019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43020 if (!SWIG_IsOK(res1)) {
43021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43022 }
43023 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43024 {
43025 PyThreadState* __tstate = wxPyBeginAllowThreads();
43026 delete arg1;
43027
43028 wxPyEndAllowThreads(__tstate);
43029 if (PyErr_Occurred()) SWIG_fail;
43030 }
43031 resultobj = SWIG_Py_Void();
43032 return resultobj;
43033 fail:
43034 return NULL;
43035 }
43036
43037
43038 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43039 PyObject *resultobj = 0;
43040 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43041 wxMenu *result = 0 ;
43042 void *argp1 = 0 ;
43043 int res1 = 0 ;
43044 PyObject *swig_obj[1] ;
43045
43046 if (!args) SWIG_fail;
43047 swig_obj[0] = args;
43048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43049 if (!SWIG_IsOK(res1)) {
43050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43051 }
43052 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43053 {
43054 PyThreadState* __tstate = wxPyBeginAllowThreads();
43055 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
43056 wxPyEndAllowThreads(__tstate);
43057 if (PyErr_Occurred()) SWIG_fail;
43058 }
43059 {
43060 resultobj = wxPyMake_wxObject(result, 0);
43061 }
43062 return resultobj;
43063 fail:
43064 return NULL;
43065 }
43066
43067
43068 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43069 PyObject *resultobj = 0;
43070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43071 wxMenu *arg2 = (wxMenu *) 0 ;
43072 void *argp1 = 0 ;
43073 int res1 = 0 ;
43074 void *argp2 = 0 ;
43075 int res2 = 0 ;
43076 PyObject * obj0 = 0 ;
43077 PyObject * obj1 = 0 ;
43078 char * kwnames[] = {
43079 (char *) "self",(char *) "menu", NULL
43080 };
43081
43082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43084 if (!SWIG_IsOK(res1)) {
43085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43086 }
43087 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43088 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43089 if (!SWIG_IsOK(res2)) {
43090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43091 }
43092 arg2 = reinterpret_cast< wxMenu * >(argp2);
43093 {
43094 PyThreadState* __tstate = wxPyBeginAllowThreads();
43095 (arg1)->SetMenu(arg2);
43096 wxPyEndAllowThreads(__tstate);
43097 if (PyErr_Occurred()) SWIG_fail;
43098 }
43099 resultobj = SWIG_Py_Void();
43100 return resultobj;
43101 fail:
43102 return NULL;
43103 }
43104
43105
43106 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43107 PyObject *resultobj = 0;
43108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43109 int arg2 ;
43110 void *argp1 = 0 ;
43111 int res1 = 0 ;
43112 int val2 ;
43113 int ecode2 = 0 ;
43114 PyObject * obj0 = 0 ;
43115 PyObject * obj1 = 0 ;
43116 char * kwnames[] = {
43117 (char *) "self",(char *) "id", NULL
43118 };
43119
43120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
43121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43122 if (!SWIG_IsOK(res1)) {
43123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43124 }
43125 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43126 ecode2 = SWIG_AsVal_int(obj1, &val2);
43127 if (!SWIG_IsOK(ecode2)) {
43128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
43129 }
43130 arg2 = static_cast< int >(val2);
43131 {
43132 PyThreadState* __tstate = wxPyBeginAllowThreads();
43133 (arg1)->SetId(arg2);
43134 wxPyEndAllowThreads(__tstate);
43135 if (PyErr_Occurred()) SWIG_fail;
43136 }
43137 resultobj = SWIG_Py_Void();
43138 return resultobj;
43139 fail:
43140 return NULL;
43141 }
43142
43143
43144 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43145 PyObject *resultobj = 0;
43146 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43147 int result;
43148 void *argp1 = 0 ;
43149 int res1 = 0 ;
43150 PyObject *swig_obj[1] ;
43151
43152 if (!args) SWIG_fail;
43153 swig_obj[0] = args;
43154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43155 if (!SWIG_IsOK(res1)) {
43156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43157 }
43158 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43159 {
43160 PyThreadState* __tstate = wxPyBeginAllowThreads();
43161 result = (int)((wxMenuItem const *)arg1)->GetId();
43162 wxPyEndAllowThreads(__tstate);
43163 if (PyErr_Occurred()) SWIG_fail;
43164 }
43165 resultobj = SWIG_From_int(static_cast< int >(result));
43166 return resultobj;
43167 fail:
43168 return NULL;
43169 }
43170
43171
43172 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43173 PyObject *resultobj = 0;
43174 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43175 bool result;
43176 void *argp1 = 0 ;
43177 int res1 = 0 ;
43178 PyObject *swig_obj[1] ;
43179
43180 if (!args) SWIG_fail;
43181 swig_obj[0] = args;
43182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43183 if (!SWIG_IsOK(res1)) {
43184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43185 }
43186 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43187 {
43188 PyThreadState* __tstate = wxPyBeginAllowThreads();
43189 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
43190 wxPyEndAllowThreads(__tstate);
43191 if (PyErr_Occurred()) SWIG_fail;
43192 }
43193 {
43194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43195 }
43196 return resultobj;
43197 fail:
43198 return NULL;
43199 }
43200
43201
43202 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43203 PyObject *resultobj = 0;
43204 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43205 wxString *arg2 = 0 ;
43206 void *argp1 = 0 ;
43207 int res1 = 0 ;
43208 bool temp2 = false ;
43209 PyObject * obj0 = 0 ;
43210 PyObject * obj1 = 0 ;
43211 char * kwnames[] = {
43212 (char *) "self",(char *) "str", NULL
43213 };
43214
43215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
43216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43217 if (!SWIG_IsOK(res1)) {
43218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43219 }
43220 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43221 {
43222 arg2 = wxString_in_helper(obj1);
43223 if (arg2 == NULL) SWIG_fail;
43224 temp2 = true;
43225 }
43226 {
43227 PyThreadState* __tstate = wxPyBeginAllowThreads();
43228 (arg1)->SetText((wxString const &)*arg2);
43229 wxPyEndAllowThreads(__tstate);
43230 if (PyErr_Occurred()) SWIG_fail;
43231 }
43232 resultobj = SWIG_Py_Void();
43233 {
43234 if (temp2)
43235 delete arg2;
43236 }
43237 return resultobj;
43238 fail:
43239 {
43240 if (temp2)
43241 delete arg2;
43242 }
43243 return NULL;
43244 }
43245
43246
43247 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43248 PyObject *resultobj = 0;
43249 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43250 wxString result;
43251 void *argp1 = 0 ;
43252 int res1 = 0 ;
43253 PyObject *swig_obj[1] ;
43254
43255 if (!args) SWIG_fail;
43256 swig_obj[0] = args;
43257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43258 if (!SWIG_IsOK(res1)) {
43259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43260 }
43261 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43262 {
43263 PyThreadState* __tstate = wxPyBeginAllowThreads();
43264 result = ((wxMenuItem const *)arg1)->GetLabel();
43265 wxPyEndAllowThreads(__tstate);
43266 if (PyErr_Occurred()) SWIG_fail;
43267 }
43268 {
43269 #if wxUSE_UNICODE
43270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43271 #else
43272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43273 #endif
43274 }
43275 return resultobj;
43276 fail:
43277 return NULL;
43278 }
43279
43280
43281 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43282 PyObject *resultobj = 0;
43283 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43284 wxString *result = 0 ;
43285 void *argp1 = 0 ;
43286 int res1 = 0 ;
43287 PyObject *swig_obj[1] ;
43288
43289 if (!args) SWIG_fail;
43290 swig_obj[0] = args;
43291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43292 if (!SWIG_IsOK(res1)) {
43293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43294 }
43295 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43296 {
43297 PyThreadState* __tstate = wxPyBeginAllowThreads();
43298 {
43299 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
43300 result = (wxString *) &_result_ref;
43301 }
43302 wxPyEndAllowThreads(__tstate);
43303 if (PyErr_Occurred()) SWIG_fail;
43304 }
43305 {
43306 #if wxUSE_UNICODE
43307 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43308 #else
43309 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43310 #endif
43311 }
43312 return resultobj;
43313 fail:
43314 return NULL;
43315 }
43316
43317
43318 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43319 PyObject *resultobj = 0;
43320 wxString *arg1 = 0 ;
43321 wxString result;
43322 bool temp1 = false ;
43323 PyObject * obj0 = 0 ;
43324 char * kwnames[] = {
43325 (char *) "text", NULL
43326 };
43327
43328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
43329 {
43330 arg1 = wxString_in_helper(obj0);
43331 if (arg1 == NULL) SWIG_fail;
43332 temp1 = true;
43333 }
43334 {
43335 PyThreadState* __tstate = wxPyBeginAllowThreads();
43336 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
43337 wxPyEndAllowThreads(__tstate);
43338 if (PyErr_Occurred()) SWIG_fail;
43339 }
43340 {
43341 #if wxUSE_UNICODE
43342 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43343 #else
43344 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43345 #endif
43346 }
43347 {
43348 if (temp1)
43349 delete arg1;
43350 }
43351 return resultobj;
43352 fail:
43353 {
43354 if (temp1)
43355 delete arg1;
43356 }
43357 return NULL;
43358 }
43359
43360
43361 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43362 PyObject *resultobj = 0;
43363 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43364 wxItemKind result;
43365 void *argp1 = 0 ;
43366 int res1 = 0 ;
43367 PyObject *swig_obj[1] ;
43368
43369 if (!args) SWIG_fail;
43370 swig_obj[0] = args;
43371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43372 if (!SWIG_IsOK(res1)) {
43373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43374 }
43375 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43376 {
43377 PyThreadState* __tstate = wxPyBeginAllowThreads();
43378 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
43379 wxPyEndAllowThreads(__tstate);
43380 if (PyErr_Occurred()) SWIG_fail;
43381 }
43382 resultobj = SWIG_From_int(static_cast< int >(result));
43383 return resultobj;
43384 fail:
43385 return NULL;
43386 }
43387
43388
43389 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43390 PyObject *resultobj = 0;
43391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43392 wxItemKind arg2 ;
43393 void *argp1 = 0 ;
43394 int res1 = 0 ;
43395 int val2 ;
43396 int ecode2 = 0 ;
43397 PyObject * obj0 = 0 ;
43398 PyObject * obj1 = 0 ;
43399 char * kwnames[] = {
43400 (char *) "self",(char *) "kind", NULL
43401 };
43402
43403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
43404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43405 if (!SWIG_IsOK(res1)) {
43406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43407 }
43408 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43409 ecode2 = SWIG_AsVal_int(obj1, &val2);
43410 if (!SWIG_IsOK(ecode2)) {
43411 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
43412 }
43413 arg2 = static_cast< wxItemKind >(val2);
43414 {
43415 PyThreadState* __tstate = wxPyBeginAllowThreads();
43416 (arg1)->SetKind(arg2);
43417 wxPyEndAllowThreads(__tstate);
43418 if (PyErr_Occurred()) SWIG_fail;
43419 }
43420 resultobj = SWIG_Py_Void();
43421 return resultobj;
43422 fail:
43423 return NULL;
43424 }
43425
43426
43427 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43428 PyObject *resultobj = 0;
43429 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43430 bool arg2 ;
43431 void *argp1 = 0 ;
43432 int res1 = 0 ;
43433 bool val2 ;
43434 int ecode2 = 0 ;
43435 PyObject * obj0 = 0 ;
43436 PyObject * obj1 = 0 ;
43437 char * kwnames[] = {
43438 (char *) "self",(char *) "checkable", NULL
43439 };
43440
43441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
43442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43443 if (!SWIG_IsOK(res1)) {
43444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43445 }
43446 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43447 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43448 if (!SWIG_IsOK(ecode2)) {
43449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
43450 }
43451 arg2 = static_cast< bool >(val2);
43452 {
43453 PyThreadState* __tstate = wxPyBeginAllowThreads();
43454 (arg1)->SetCheckable(arg2);
43455 wxPyEndAllowThreads(__tstate);
43456 if (PyErr_Occurred()) SWIG_fail;
43457 }
43458 resultobj = SWIG_Py_Void();
43459 return resultobj;
43460 fail:
43461 return NULL;
43462 }
43463
43464
43465 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43466 PyObject *resultobj = 0;
43467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43468 bool result;
43469 void *argp1 = 0 ;
43470 int res1 = 0 ;
43471 PyObject *swig_obj[1] ;
43472
43473 if (!args) SWIG_fail;
43474 swig_obj[0] = args;
43475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43476 if (!SWIG_IsOK(res1)) {
43477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43478 }
43479 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43480 {
43481 PyThreadState* __tstate = wxPyBeginAllowThreads();
43482 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
43483 wxPyEndAllowThreads(__tstate);
43484 if (PyErr_Occurred()) SWIG_fail;
43485 }
43486 {
43487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43488 }
43489 return resultobj;
43490 fail:
43491 return NULL;
43492 }
43493
43494
43495 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43496 PyObject *resultobj = 0;
43497 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43498 bool result;
43499 void *argp1 = 0 ;
43500 int res1 = 0 ;
43501 PyObject *swig_obj[1] ;
43502
43503 if (!args) SWIG_fail;
43504 swig_obj[0] = args;
43505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43506 if (!SWIG_IsOK(res1)) {
43507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43508 }
43509 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43510 {
43511 PyThreadState* __tstate = wxPyBeginAllowThreads();
43512 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
43513 wxPyEndAllowThreads(__tstate);
43514 if (PyErr_Occurred()) SWIG_fail;
43515 }
43516 {
43517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43518 }
43519 return resultobj;
43520 fail:
43521 return NULL;
43522 }
43523
43524
43525 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43526 PyObject *resultobj = 0;
43527 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43528 wxMenu *arg2 = (wxMenu *) 0 ;
43529 void *argp1 = 0 ;
43530 int res1 = 0 ;
43531 void *argp2 = 0 ;
43532 int res2 = 0 ;
43533 PyObject * obj0 = 0 ;
43534 PyObject * obj1 = 0 ;
43535 char * kwnames[] = {
43536 (char *) "self",(char *) "menu", NULL
43537 };
43538
43539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
43540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43541 if (!SWIG_IsOK(res1)) {
43542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43543 }
43544 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43545 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
43546 if (!SWIG_IsOK(res2)) {
43547 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
43548 }
43549 arg2 = reinterpret_cast< wxMenu * >(argp2);
43550 {
43551 PyThreadState* __tstate = wxPyBeginAllowThreads();
43552 (arg1)->SetSubMenu(arg2);
43553 wxPyEndAllowThreads(__tstate);
43554 if (PyErr_Occurred()) SWIG_fail;
43555 }
43556 resultobj = SWIG_Py_Void();
43557 return resultobj;
43558 fail:
43559 return NULL;
43560 }
43561
43562
43563 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43564 PyObject *resultobj = 0;
43565 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43566 wxMenu *result = 0 ;
43567 void *argp1 = 0 ;
43568 int res1 = 0 ;
43569 PyObject *swig_obj[1] ;
43570
43571 if (!args) SWIG_fail;
43572 swig_obj[0] = args;
43573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43574 if (!SWIG_IsOK(res1)) {
43575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43576 }
43577 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43578 {
43579 PyThreadState* __tstate = wxPyBeginAllowThreads();
43580 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
43581 wxPyEndAllowThreads(__tstate);
43582 if (PyErr_Occurred()) SWIG_fail;
43583 }
43584 {
43585 resultobj = wxPyMake_wxObject(result, 0);
43586 }
43587 return resultobj;
43588 fail:
43589 return NULL;
43590 }
43591
43592
43593 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43594 PyObject *resultobj = 0;
43595 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43596 bool arg2 = (bool) true ;
43597 void *argp1 = 0 ;
43598 int res1 = 0 ;
43599 bool val2 ;
43600 int ecode2 = 0 ;
43601 PyObject * obj0 = 0 ;
43602 PyObject * obj1 = 0 ;
43603 char * kwnames[] = {
43604 (char *) "self",(char *) "enable", NULL
43605 };
43606
43607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
43608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43609 if (!SWIG_IsOK(res1)) {
43610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43611 }
43612 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43613 if (obj1) {
43614 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43615 if (!SWIG_IsOK(ecode2)) {
43616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
43617 }
43618 arg2 = static_cast< bool >(val2);
43619 }
43620 {
43621 PyThreadState* __tstate = wxPyBeginAllowThreads();
43622 (arg1)->Enable(arg2);
43623 wxPyEndAllowThreads(__tstate);
43624 if (PyErr_Occurred()) SWIG_fail;
43625 }
43626 resultobj = SWIG_Py_Void();
43627 return resultobj;
43628 fail:
43629 return NULL;
43630 }
43631
43632
43633 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43634 PyObject *resultobj = 0;
43635 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43636 bool result;
43637 void *argp1 = 0 ;
43638 int res1 = 0 ;
43639 PyObject *swig_obj[1] ;
43640
43641 if (!args) SWIG_fail;
43642 swig_obj[0] = args;
43643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43644 if (!SWIG_IsOK(res1)) {
43645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43646 }
43647 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43648 {
43649 PyThreadState* __tstate = wxPyBeginAllowThreads();
43650 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
43651 wxPyEndAllowThreads(__tstate);
43652 if (PyErr_Occurred()) SWIG_fail;
43653 }
43654 {
43655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43656 }
43657 return resultobj;
43658 fail:
43659 return NULL;
43660 }
43661
43662
43663 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43664 PyObject *resultobj = 0;
43665 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43666 bool arg2 = (bool) true ;
43667 void *argp1 = 0 ;
43668 int res1 = 0 ;
43669 bool val2 ;
43670 int ecode2 = 0 ;
43671 PyObject * obj0 = 0 ;
43672 PyObject * obj1 = 0 ;
43673 char * kwnames[] = {
43674 (char *) "self",(char *) "check", NULL
43675 };
43676
43677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
43678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43679 if (!SWIG_IsOK(res1)) {
43680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43681 }
43682 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43683 if (obj1) {
43684 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43685 if (!SWIG_IsOK(ecode2)) {
43686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
43687 }
43688 arg2 = static_cast< bool >(val2);
43689 }
43690 {
43691 PyThreadState* __tstate = wxPyBeginAllowThreads();
43692 (arg1)->Check(arg2);
43693 wxPyEndAllowThreads(__tstate);
43694 if (PyErr_Occurred()) SWIG_fail;
43695 }
43696 resultobj = SWIG_Py_Void();
43697 return resultobj;
43698 fail:
43699 return NULL;
43700 }
43701
43702
43703 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43704 PyObject *resultobj = 0;
43705 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43706 bool result;
43707 void *argp1 = 0 ;
43708 int res1 = 0 ;
43709 PyObject *swig_obj[1] ;
43710
43711 if (!args) SWIG_fail;
43712 swig_obj[0] = args;
43713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43714 if (!SWIG_IsOK(res1)) {
43715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43716 }
43717 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43718 {
43719 PyThreadState* __tstate = wxPyBeginAllowThreads();
43720 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43721 wxPyEndAllowThreads(__tstate);
43722 if (PyErr_Occurred()) SWIG_fail;
43723 }
43724 {
43725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43726 }
43727 return resultobj;
43728 fail:
43729 return NULL;
43730 }
43731
43732
43733 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43734 PyObject *resultobj = 0;
43735 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43736 void *argp1 = 0 ;
43737 int res1 = 0 ;
43738 PyObject *swig_obj[1] ;
43739
43740 if (!args) SWIG_fail;
43741 swig_obj[0] = args;
43742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43743 if (!SWIG_IsOK(res1)) {
43744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43745 }
43746 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43747 {
43748 PyThreadState* __tstate = wxPyBeginAllowThreads();
43749 (arg1)->Toggle();
43750 wxPyEndAllowThreads(__tstate);
43751 if (PyErr_Occurred()) SWIG_fail;
43752 }
43753 resultobj = SWIG_Py_Void();
43754 return resultobj;
43755 fail:
43756 return NULL;
43757 }
43758
43759
43760 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43761 PyObject *resultobj = 0;
43762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43763 wxString *arg2 = 0 ;
43764 void *argp1 = 0 ;
43765 int res1 = 0 ;
43766 bool temp2 = false ;
43767 PyObject * obj0 = 0 ;
43768 PyObject * obj1 = 0 ;
43769 char * kwnames[] = {
43770 (char *) "self",(char *) "str", NULL
43771 };
43772
43773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43775 if (!SWIG_IsOK(res1)) {
43776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43777 }
43778 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43779 {
43780 arg2 = wxString_in_helper(obj1);
43781 if (arg2 == NULL) SWIG_fail;
43782 temp2 = true;
43783 }
43784 {
43785 PyThreadState* __tstate = wxPyBeginAllowThreads();
43786 (arg1)->SetHelp((wxString const &)*arg2);
43787 wxPyEndAllowThreads(__tstate);
43788 if (PyErr_Occurred()) SWIG_fail;
43789 }
43790 resultobj = SWIG_Py_Void();
43791 {
43792 if (temp2)
43793 delete arg2;
43794 }
43795 return resultobj;
43796 fail:
43797 {
43798 if (temp2)
43799 delete arg2;
43800 }
43801 return NULL;
43802 }
43803
43804
43805 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43806 PyObject *resultobj = 0;
43807 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43808 wxString *result = 0 ;
43809 void *argp1 = 0 ;
43810 int res1 = 0 ;
43811 PyObject *swig_obj[1] ;
43812
43813 if (!args) SWIG_fail;
43814 swig_obj[0] = args;
43815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43816 if (!SWIG_IsOK(res1)) {
43817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43818 }
43819 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43820 {
43821 PyThreadState* __tstate = wxPyBeginAllowThreads();
43822 {
43823 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43824 result = (wxString *) &_result_ref;
43825 }
43826 wxPyEndAllowThreads(__tstate);
43827 if (PyErr_Occurred()) SWIG_fail;
43828 }
43829 {
43830 #if wxUSE_UNICODE
43831 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43832 #else
43833 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43834 #endif
43835 }
43836 return resultobj;
43837 fail:
43838 return NULL;
43839 }
43840
43841
43842 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43843 PyObject *resultobj = 0;
43844 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43845 wxAcceleratorEntry *result = 0 ;
43846 void *argp1 = 0 ;
43847 int res1 = 0 ;
43848 PyObject *swig_obj[1] ;
43849
43850 if (!args) SWIG_fail;
43851 swig_obj[0] = args;
43852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43853 if (!SWIG_IsOK(res1)) {
43854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43855 }
43856 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43857 {
43858 PyThreadState* __tstate = wxPyBeginAllowThreads();
43859 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43860 wxPyEndAllowThreads(__tstate);
43861 if (PyErr_Occurred()) SWIG_fail;
43862 }
43863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43864 return resultobj;
43865 fail:
43866 return NULL;
43867 }
43868
43869
43870 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43871 PyObject *resultobj = 0;
43872 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43873 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43874 void *argp1 = 0 ;
43875 int res1 = 0 ;
43876 void *argp2 = 0 ;
43877 int res2 = 0 ;
43878 PyObject * obj0 = 0 ;
43879 PyObject * obj1 = 0 ;
43880 char * kwnames[] = {
43881 (char *) "self",(char *) "accel", NULL
43882 };
43883
43884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43886 if (!SWIG_IsOK(res1)) {
43887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43888 }
43889 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43890 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43891 if (!SWIG_IsOK(res2)) {
43892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43893 }
43894 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43895 {
43896 PyThreadState* __tstate = wxPyBeginAllowThreads();
43897 (arg1)->SetAccel(arg2);
43898 wxPyEndAllowThreads(__tstate);
43899 if (PyErr_Occurred()) SWIG_fail;
43900 }
43901 resultobj = SWIG_Py_Void();
43902 return resultobj;
43903 fail:
43904 return NULL;
43905 }
43906
43907
43908 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43909 PyObject *resultobj = 0;
43910 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43911 wxBitmap *arg2 = 0 ;
43912 void *argp1 = 0 ;
43913 int res1 = 0 ;
43914 void *argp2 = 0 ;
43915 int res2 = 0 ;
43916 PyObject * obj0 = 0 ;
43917 PyObject * obj1 = 0 ;
43918 char * kwnames[] = {
43919 (char *) "self",(char *) "bitmap", NULL
43920 };
43921
43922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43924 if (!SWIG_IsOK(res1)) {
43925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43926 }
43927 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43928 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43929 if (!SWIG_IsOK(res2)) {
43930 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43931 }
43932 if (!argp2) {
43933 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43934 }
43935 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43936 {
43937 PyThreadState* __tstate = wxPyBeginAllowThreads();
43938 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43939 wxPyEndAllowThreads(__tstate);
43940 if (PyErr_Occurred()) SWIG_fail;
43941 }
43942 resultobj = SWIG_Py_Void();
43943 return resultobj;
43944 fail:
43945 return NULL;
43946 }
43947
43948
43949 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43950 PyObject *resultobj = 0;
43951 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43952 wxBitmap *result = 0 ;
43953 void *argp1 = 0 ;
43954 int res1 = 0 ;
43955 PyObject *swig_obj[1] ;
43956
43957 if (!args) SWIG_fail;
43958 swig_obj[0] = args;
43959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43960 if (!SWIG_IsOK(res1)) {
43961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43962 }
43963 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43964 {
43965 PyThreadState* __tstate = wxPyBeginAllowThreads();
43966 {
43967 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43968 result = (wxBitmap *) &_result_ref;
43969 }
43970 wxPyEndAllowThreads(__tstate);
43971 if (PyErr_Occurred()) SWIG_fail;
43972 }
43973 {
43974 wxBitmap* resultptr = new wxBitmap(*result);
43975 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43976 }
43977 return resultobj;
43978 fail:
43979 return NULL;
43980 }
43981
43982
43983 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43984 PyObject *resultobj = 0;
43985 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43986 wxFont *arg2 = 0 ;
43987 void *argp1 = 0 ;
43988 int res1 = 0 ;
43989 void *argp2 = 0 ;
43990 int res2 = 0 ;
43991 PyObject * obj0 = 0 ;
43992 PyObject * obj1 = 0 ;
43993 char * kwnames[] = {
43994 (char *) "self",(char *) "font", NULL
43995 };
43996
43997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43999 if (!SWIG_IsOK(res1)) {
44000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44001 }
44002 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44003 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
44004 if (!SWIG_IsOK(res2)) {
44005 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44006 }
44007 if (!argp2) {
44008 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
44009 }
44010 arg2 = reinterpret_cast< wxFont * >(argp2);
44011 {
44012 PyThreadState* __tstate = wxPyBeginAllowThreads();
44013 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
44014 wxPyEndAllowThreads(__tstate);
44015 if (PyErr_Occurred()) SWIG_fail;
44016 }
44017 resultobj = SWIG_Py_Void();
44018 return resultobj;
44019 fail:
44020 return NULL;
44021 }
44022
44023
44024 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44025 PyObject *resultobj = 0;
44026 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44027 wxFont result;
44028 void *argp1 = 0 ;
44029 int res1 = 0 ;
44030 PyObject *swig_obj[1] ;
44031
44032 if (!args) SWIG_fail;
44033 swig_obj[0] = args;
44034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44035 if (!SWIG_IsOK(res1)) {
44036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44037 }
44038 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44039 {
44040 PyThreadState* __tstate = wxPyBeginAllowThreads();
44041 result = wxMenuItem_GetFont(arg1);
44042 wxPyEndAllowThreads(__tstate);
44043 if (PyErr_Occurred()) SWIG_fail;
44044 }
44045 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
44046 return resultobj;
44047 fail:
44048 return NULL;
44049 }
44050
44051
44052 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44053 PyObject *resultobj = 0;
44054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44055 wxColour *arg2 = 0 ;
44056 void *argp1 = 0 ;
44057 int res1 = 0 ;
44058 wxColour temp2 ;
44059 PyObject * obj0 = 0 ;
44060 PyObject * obj1 = 0 ;
44061 char * kwnames[] = {
44062 (char *) "self",(char *) "colText", NULL
44063 };
44064
44065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
44066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44067 if (!SWIG_IsOK(res1)) {
44068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44069 }
44070 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44071 {
44072 arg2 = &temp2;
44073 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44074 }
44075 {
44076 PyThreadState* __tstate = wxPyBeginAllowThreads();
44077 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
44078 wxPyEndAllowThreads(__tstate);
44079 if (PyErr_Occurred()) SWIG_fail;
44080 }
44081 resultobj = SWIG_Py_Void();
44082 return resultobj;
44083 fail:
44084 return NULL;
44085 }
44086
44087
44088 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44089 PyObject *resultobj = 0;
44090 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44091 wxColour result;
44092 void *argp1 = 0 ;
44093 int res1 = 0 ;
44094 PyObject *swig_obj[1] ;
44095
44096 if (!args) SWIG_fail;
44097 swig_obj[0] = args;
44098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44099 if (!SWIG_IsOK(res1)) {
44100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44101 }
44102 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44103 {
44104 PyThreadState* __tstate = wxPyBeginAllowThreads();
44105 result = wxMenuItem_GetTextColour(arg1);
44106 wxPyEndAllowThreads(__tstate);
44107 if (PyErr_Occurred()) SWIG_fail;
44108 }
44109 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44110 return resultobj;
44111 fail:
44112 return NULL;
44113 }
44114
44115
44116 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44117 PyObject *resultobj = 0;
44118 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44119 wxColour *arg2 = 0 ;
44120 void *argp1 = 0 ;
44121 int res1 = 0 ;
44122 wxColour temp2 ;
44123 PyObject * obj0 = 0 ;
44124 PyObject * obj1 = 0 ;
44125 char * kwnames[] = {
44126 (char *) "self",(char *) "colBack", NULL
44127 };
44128
44129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
44130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44131 if (!SWIG_IsOK(res1)) {
44132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44133 }
44134 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44135 {
44136 arg2 = &temp2;
44137 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
44138 }
44139 {
44140 PyThreadState* __tstate = wxPyBeginAllowThreads();
44141 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
44142 wxPyEndAllowThreads(__tstate);
44143 if (PyErr_Occurred()) SWIG_fail;
44144 }
44145 resultobj = SWIG_Py_Void();
44146 return resultobj;
44147 fail:
44148 return NULL;
44149 }
44150
44151
44152 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44153 PyObject *resultobj = 0;
44154 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44155 wxColour result;
44156 void *argp1 = 0 ;
44157 int res1 = 0 ;
44158 PyObject *swig_obj[1] ;
44159
44160 if (!args) SWIG_fail;
44161 swig_obj[0] = args;
44162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44163 if (!SWIG_IsOK(res1)) {
44164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44165 }
44166 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44167 {
44168 PyThreadState* __tstate = wxPyBeginAllowThreads();
44169 result = wxMenuItem_GetBackgroundColour(arg1);
44170 wxPyEndAllowThreads(__tstate);
44171 if (PyErr_Occurred()) SWIG_fail;
44172 }
44173 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
44174 return resultobj;
44175 fail:
44176 return NULL;
44177 }
44178
44179
44180 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44181 PyObject *resultobj = 0;
44182 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44183 wxBitmap *arg2 = 0 ;
44184 wxBitmap const &arg3_defvalue = wxNullBitmap ;
44185 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
44186 void *argp1 = 0 ;
44187 int res1 = 0 ;
44188 void *argp2 = 0 ;
44189 int res2 = 0 ;
44190 void *argp3 = 0 ;
44191 int res3 = 0 ;
44192 PyObject * obj0 = 0 ;
44193 PyObject * obj1 = 0 ;
44194 PyObject * obj2 = 0 ;
44195 char * kwnames[] = {
44196 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
44197 };
44198
44199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44201 if (!SWIG_IsOK(res1)) {
44202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44203 }
44204 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44205 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44206 if (!SWIG_IsOK(res2)) {
44207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44208 }
44209 if (!argp2) {
44210 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44211 }
44212 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44213 if (obj2) {
44214 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
44215 if (!SWIG_IsOK(res3)) {
44216 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44217 }
44218 if (!argp3) {
44219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
44220 }
44221 arg3 = reinterpret_cast< wxBitmap * >(argp3);
44222 }
44223 {
44224 PyThreadState* __tstate = wxPyBeginAllowThreads();
44225 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
44226 wxPyEndAllowThreads(__tstate);
44227 if (PyErr_Occurred()) SWIG_fail;
44228 }
44229 resultobj = SWIG_Py_Void();
44230 return resultobj;
44231 fail:
44232 return NULL;
44233 }
44234
44235
44236 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44237 PyObject *resultobj = 0;
44238 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44239 wxBitmap *arg2 = 0 ;
44240 void *argp1 = 0 ;
44241 int res1 = 0 ;
44242 void *argp2 = 0 ;
44243 int res2 = 0 ;
44244 PyObject * obj0 = 0 ;
44245 PyObject * obj1 = 0 ;
44246 char * kwnames[] = {
44247 (char *) "self",(char *) "bmpDisabled", NULL
44248 };
44249
44250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
44251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44252 if (!SWIG_IsOK(res1)) {
44253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44254 }
44255 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44256 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
44257 if (!SWIG_IsOK(res2)) {
44258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44259 }
44260 if (!argp2) {
44261 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
44262 }
44263 arg2 = reinterpret_cast< wxBitmap * >(argp2);
44264 {
44265 PyThreadState* __tstate = wxPyBeginAllowThreads();
44266 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
44267 wxPyEndAllowThreads(__tstate);
44268 if (PyErr_Occurred()) SWIG_fail;
44269 }
44270 resultobj = SWIG_Py_Void();
44271 return resultobj;
44272 fail:
44273 return NULL;
44274 }
44275
44276
44277 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44278 PyObject *resultobj = 0;
44279 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44280 wxBitmap *result = 0 ;
44281 void *argp1 = 0 ;
44282 int res1 = 0 ;
44283 PyObject *swig_obj[1] ;
44284
44285 if (!args) SWIG_fail;
44286 swig_obj[0] = args;
44287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44288 if (!SWIG_IsOK(res1)) {
44289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
44290 }
44291 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44292 {
44293 PyThreadState* __tstate = wxPyBeginAllowThreads();
44294 {
44295 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
44296 result = (wxBitmap *) &_result_ref;
44297 }
44298 wxPyEndAllowThreads(__tstate);
44299 if (PyErr_Occurred()) SWIG_fail;
44300 }
44301 {
44302 wxBitmap* resultptr = new wxBitmap(*result);
44303 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
44304 }
44305 return resultobj;
44306 fail:
44307 return NULL;
44308 }
44309
44310
44311 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44312 PyObject *resultobj = 0;
44313 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44314 int arg2 ;
44315 void *argp1 = 0 ;
44316 int res1 = 0 ;
44317 int val2 ;
44318 int ecode2 = 0 ;
44319 PyObject * obj0 = 0 ;
44320 PyObject * obj1 = 0 ;
44321 char * kwnames[] = {
44322 (char *) "self",(char *) "nWidth", NULL
44323 };
44324
44325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
44326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44327 if (!SWIG_IsOK(res1)) {
44328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44329 }
44330 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44331 ecode2 = SWIG_AsVal_int(obj1, &val2);
44332 if (!SWIG_IsOK(ecode2)) {
44333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
44334 }
44335 arg2 = static_cast< int >(val2);
44336 {
44337 PyThreadState* __tstate = wxPyBeginAllowThreads();
44338 wxMenuItem_SetMarginWidth(arg1,arg2);
44339 wxPyEndAllowThreads(__tstate);
44340 if (PyErr_Occurred()) SWIG_fail;
44341 }
44342 resultobj = SWIG_Py_Void();
44343 return resultobj;
44344 fail:
44345 return NULL;
44346 }
44347
44348
44349 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44350 PyObject *resultobj = 0;
44351 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44352 int result;
44353 void *argp1 = 0 ;
44354 int res1 = 0 ;
44355 PyObject *swig_obj[1] ;
44356
44357 if (!args) SWIG_fail;
44358 swig_obj[0] = args;
44359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44360 if (!SWIG_IsOK(res1)) {
44361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44362 }
44363 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44364 {
44365 PyThreadState* __tstate = wxPyBeginAllowThreads();
44366 result = (int)wxMenuItem_GetMarginWidth(arg1);
44367 wxPyEndAllowThreads(__tstate);
44368 if (PyErr_Occurred()) SWIG_fail;
44369 }
44370 resultobj = SWIG_From_int(static_cast< int >(result));
44371 return resultobj;
44372 fail:
44373 return NULL;
44374 }
44375
44376
44377 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44378 PyObject *resultobj = 0;
44379 int result;
44380
44381 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
44382 {
44383 PyThreadState* __tstate = wxPyBeginAllowThreads();
44384 result = (int)wxMenuItem_GetDefaultMarginWidth();
44385 wxPyEndAllowThreads(__tstate);
44386 if (PyErr_Occurred()) SWIG_fail;
44387 }
44388 resultobj = SWIG_From_int(static_cast< int >(result));
44389 return resultobj;
44390 fail:
44391 return NULL;
44392 }
44393
44394
44395 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44396 PyObject *resultobj = 0;
44397 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44398 bool result;
44399 void *argp1 = 0 ;
44400 int res1 = 0 ;
44401 PyObject *swig_obj[1] ;
44402
44403 if (!args) SWIG_fail;
44404 swig_obj[0] = args;
44405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44406 if (!SWIG_IsOK(res1)) {
44407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44408 }
44409 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44410 {
44411 PyThreadState* __tstate = wxPyBeginAllowThreads();
44412 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
44413 wxPyEndAllowThreads(__tstate);
44414 if (PyErr_Occurred()) SWIG_fail;
44415 }
44416 {
44417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44418 }
44419 return resultobj;
44420 fail:
44421 return NULL;
44422 }
44423
44424
44425 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44426 PyObject *resultobj = 0;
44427 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44428 bool arg2 = (bool) true ;
44429 void *argp1 = 0 ;
44430 int res1 = 0 ;
44431 bool val2 ;
44432 int ecode2 = 0 ;
44433 PyObject * obj0 = 0 ;
44434 PyObject * obj1 = 0 ;
44435 char * kwnames[] = {
44436 (char *) "self",(char *) "ownerDrawn", NULL
44437 };
44438
44439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
44440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44441 if (!SWIG_IsOK(res1)) {
44442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44443 }
44444 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44445 if (obj1) {
44446 ecode2 = SWIG_AsVal_bool(obj1, &val2);
44447 if (!SWIG_IsOK(ecode2)) {
44448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
44449 }
44450 arg2 = static_cast< bool >(val2);
44451 }
44452 {
44453 PyThreadState* __tstate = wxPyBeginAllowThreads();
44454 wxMenuItem_SetOwnerDrawn(arg1,arg2);
44455 wxPyEndAllowThreads(__tstate);
44456 if (PyErr_Occurred()) SWIG_fail;
44457 }
44458 resultobj = SWIG_Py_Void();
44459 return resultobj;
44460 fail:
44461 return NULL;
44462 }
44463
44464
44465 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44466 PyObject *resultobj = 0;
44467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
44468 void *argp1 = 0 ;
44469 int res1 = 0 ;
44470 PyObject *swig_obj[1] ;
44471
44472 if (!args) SWIG_fail;
44473 swig_obj[0] = args;
44474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44475 if (!SWIG_IsOK(res1)) {
44476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
44477 }
44478 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
44479 {
44480 PyThreadState* __tstate = wxPyBeginAllowThreads();
44481 wxMenuItem_ResetOwnerDrawn(arg1);
44482 wxPyEndAllowThreads(__tstate);
44483 if (PyErr_Occurred()) SWIG_fail;
44484 }
44485 resultobj = SWIG_Py_Void();
44486 return resultobj;
44487 fail:
44488 return NULL;
44489 }
44490
44491
44492 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44493 PyObject *obj;
44494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44495 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
44496 return SWIG_Py_Void();
44497 }
44498
44499 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44500 return SWIG_Python_InitShadowInstance(args);
44501 }
44502
44503 SWIGINTERN int ControlNameStr_set(PyObject *) {
44504 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
44505 return 1;
44506 }
44507
44508
44509 SWIGINTERN PyObject *ControlNameStr_get(void) {
44510 PyObject *pyobj = 0;
44511
44512 {
44513 #if wxUSE_UNICODE
44514 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44515 #else
44516 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
44517 #endif
44518 }
44519 return pyobj;
44520 }
44521
44522
44523 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44524 PyObject *resultobj = 0;
44525 wxWindow *arg1 = (wxWindow *) 0 ;
44526 int arg2 = (int) -1 ;
44527 wxPoint const &arg3_defvalue = wxDefaultPosition ;
44528 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
44529 wxSize const &arg4_defvalue = wxDefaultSize ;
44530 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
44531 long arg5 = (long) 0 ;
44532 wxValidator const &arg6_defvalue = wxDefaultValidator ;
44533 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
44534 wxString const &arg7_defvalue = wxPyControlNameStr ;
44535 wxString *arg7 = (wxString *) &arg7_defvalue ;
44536 wxControl *result = 0 ;
44537 void *argp1 = 0 ;
44538 int res1 = 0 ;
44539 int val2 ;
44540 int ecode2 = 0 ;
44541 wxPoint temp3 ;
44542 wxSize temp4 ;
44543 long val5 ;
44544 int ecode5 = 0 ;
44545 void *argp6 = 0 ;
44546 int res6 = 0 ;
44547 bool temp7 = false ;
44548 PyObject * obj0 = 0 ;
44549 PyObject * obj1 = 0 ;
44550 PyObject * obj2 = 0 ;
44551 PyObject * obj3 = 0 ;
44552 PyObject * obj4 = 0 ;
44553 PyObject * obj5 = 0 ;
44554 PyObject * obj6 = 0 ;
44555 char * kwnames[] = {
44556 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44557 };
44558
44559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
44560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44561 if (!SWIG_IsOK(res1)) {
44562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
44563 }
44564 arg1 = reinterpret_cast< wxWindow * >(argp1);
44565 if (obj1) {
44566 ecode2 = SWIG_AsVal_int(obj1, &val2);
44567 if (!SWIG_IsOK(ecode2)) {
44568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
44569 }
44570 arg2 = static_cast< int >(val2);
44571 }
44572 if (obj2) {
44573 {
44574 arg3 = &temp3;
44575 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
44576 }
44577 }
44578 if (obj3) {
44579 {
44580 arg4 = &temp4;
44581 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
44582 }
44583 }
44584 if (obj4) {
44585 ecode5 = SWIG_AsVal_long(obj4, &val5);
44586 if (!SWIG_IsOK(ecode5)) {
44587 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
44588 }
44589 arg5 = static_cast< long >(val5);
44590 }
44591 if (obj5) {
44592 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
44593 if (!SWIG_IsOK(res6)) {
44594 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44595 }
44596 if (!argp6) {
44597 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
44598 }
44599 arg6 = reinterpret_cast< wxValidator * >(argp6);
44600 }
44601 if (obj6) {
44602 {
44603 arg7 = wxString_in_helper(obj6);
44604 if (arg7 == NULL) SWIG_fail;
44605 temp7 = true;
44606 }
44607 }
44608 {
44609 if (!wxPyCheckForApp()) SWIG_fail;
44610 PyThreadState* __tstate = wxPyBeginAllowThreads();
44611 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
44612 wxPyEndAllowThreads(__tstate);
44613 if (PyErr_Occurred()) SWIG_fail;
44614 }
44615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
44616 {
44617 if (temp7)
44618 delete arg7;
44619 }
44620 return resultobj;
44621 fail:
44622 {
44623 if (temp7)
44624 delete arg7;
44625 }
44626 return NULL;
44627 }
44628
44629
44630 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44631 PyObject *resultobj = 0;
44632 wxControl *result = 0 ;
44633
44634 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
44635 {
44636 if (!wxPyCheckForApp()) SWIG_fail;
44637 PyThreadState* __tstate = wxPyBeginAllowThreads();
44638 result = (wxControl *)new wxControl();
44639 wxPyEndAllowThreads(__tstate);
44640 if (PyErr_Occurred()) SWIG_fail;
44641 }
44642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
44643 return resultobj;
44644 fail:
44645 return NULL;
44646 }
44647
44648
44649 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44650 PyObject *resultobj = 0;
44651 wxControl *arg1 = (wxControl *) 0 ;
44652 wxWindow *arg2 = (wxWindow *) 0 ;
44653 int arg3 = (int) -1 ;
44654 wxPoint const &arg4_defvalue = wxDefaultPosition ;
44655 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
44656 wxSize const &arg5_defvalue = wxDefaultSize ;
44657 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
44658 long arg6 = (long) 0 ;
44659 wxValidator const &arg7_defvalue = wxDefaultValidator ;
44660 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
44661 wxString const &arg8_defvalue = wxPyControlNameStr ;
44662 wxString *arg8 = (wxString *) &arg8_defvalue ;
44663 bool result;
44664 void *argp1 = 0 ;
44665 int res1 = 0 ;
44666 void *argp2 = 0 ;
44667 int res2 = 0 ;
44668 int val3 ;
44669 int ecode3 = 0 ;
44670 wxPoint temp4 ;
44671 wxSize temp5 ;
44672 long val6 ;
44673 int ecode6 = 0 ;
44674 void *argp7 = 0 ;
44675 int res7 = 0 ;
44676 bool temp8 = false ;
44677 PyObject * obj0 = 0 ;
44678 PyObject * obj1 = 0 ;
44679 PyObject * obj2 = 0 ;
44680 PyObject * obj3 = 0 ;
44681 PyObject * obj4 = 0 ;
44682 PyObject * obj5 = 0 ;
44683 PyObject * obj6 = 0 ;
44684 PyObject * obj7 = 0 ;
44685 char * kwnames[] = {
44686 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
44687 };
44688
44689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
44690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44691 if (!SWIG_IsOK(res1)) {
44692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44693 }
44694 arg1 = reinterpret_cast< wxControl * >(argp1);
44695 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44696 if (!SWIG_IsOK(res2)) {
44697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44698 }
44699 arg2 = reinterpret_cast< wxWindow * >(argp2);
44700 if (obj2) {
44701 ecode3 = SWIG_AsVal_int(obj2, &val3);
44702 if (!SWIG_IsOK(ecode3)) {
44703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44704 }
44705 arg3 = static_cast< int >(val3);
44706 }
44707 if (obj3) {
44708 {
44709 arg4 = &temp4;
44710 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44711 }
44712 }
44713 if (obj4) {
44714 {
44715 arg5 = &temp5;
44716 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44717 }
44718 }
44719 if (obj5) {
44720 ecode6 = SWIG_AsVal_long(obj5, &val6);
44721 if (!SWIG_IsOK(ecode6)) {
44722 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44723 }
44724 arg6 = static_cast< long >(val6);
44725 }
44726 if (obj6) {
44727 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44728 if (!SWIG_IsOK(res7)) {
44729 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44730 }
44731 if (!argp7) {
44732 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44733 }
44734 arg7 = reinterpret_cast< wxValidator * >(argp7);
44735 }
44736 if (obj7) {
44737 {
44738 arg8 = wxString_in_helper(obj7);
44739 if (arg8 == NULL) SWIG_fail;
44740 temp8 = true;
44741 }
44742 }
44743 {
44744 PyThreadState* __tstate = wxPyBeginAllowThreads();
44745 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44746 wxPyEndAllowThreads(__tstate);
44747 if (PyErr_Occurred()) SWIG_fail;
44748 }
44749 {
44750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44751 }
44752 {
44753 if (temp8)
44754 delete arg8;
44755 }
44756 return resultobj;
44757 fail:
44758 {
44759 if (temp8)
44760 delete arg8;
44761 }
44762 return NULL;
44763 }
44764
44765
44766 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44767 PyObject *resultobj = 0;
44768 wxControl *arg1 = (wxControl *) 0 ;
44769 int result;
44770 void *argp1 = 0 ;
44771 int res1 = 0 ;
44772 PyObject *swig_obj[1] ;
44773
44774 if (!args) SWIG_fail;
44775 swig_obj[0] = args;
44776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44777 if (!SWIG_IsOK(res1)) {
44778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44779 }
44780 arg1 = reinterpret_cast< wxControl * >(argp1);
44781 {
44782 PyThreadState* __tstate = wxPyBeginAllowThreads();
44783 result = (int)((wxControl const *)arg1)->GetAlignment();
44784 wxPyEndAllowThreads(__tstate);
44785 if (PyErr_Occurred()) SWIG_fail;
44786 }
44787 resultobj = SWIG_From_int(static_cast< int >(result));
44788 return resultobj;
44789 fail:
44790 return NULL;
44791 }
44792
44793
44794 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44795 PyObject *resultobj = 0;
44796 wxControl *arg1 = (wxControl *) 0 ;
44797 wxString result;
44798 void *argp1 = 0 ;
44799 int res1 = 0 ;
44800 PyObject *swig_obj[1] ;
44801
44802 if (!args) SWIG_fail;
44803 swig_obj[0] = args;
44804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44805 if (!SWIG_IsOK(res1)) {
44806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44807 }
44808 arg1 = reinterpret_cast< wxControl * >(argp1);
44809 {
44810 PyThreadState* __tstate = wxPyBeginAllowThreads();
44811 result = ((wxControl const *)arg1)->GetLabelText();
44812 wxPyEndAllowThreads(__tstate);
44813 if (PyErr_Occurred()) SWIG_fail;
44814 }
44815 {
44816 #if wxUSE_UNICODE
44817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44818 #else
44819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44820 #endif
44821 }
44822 return resultobj;
44823 fail:
44824 return NULL;
44825 }
44826
44827
44828 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44829 PyObject *resultobj = 0;
44830 wxControl *arg1 = (wxControl *) 0 ;
44831 wxCommandEvent *arg2 = 0 ;
44832 void *argp1 = 0 ;
44833 int res1 = 0 ;
44834 void *argp2 = 0 ;
44835 int res2 = 0 ;
44836 PyObject * obj0 = 0 ;
44837 PyObject * obj1 = 0 ;
44838 char * kwnames[] = {
44839 (char *) "self",(char *) "event", NULL
44840 };
44841
44842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44844 if (!SWIG_IsOK(res1)) {
44845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44846 }
44847 arg1 = reinterpret_cast< wxControl * >(argp1);
44848 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44849 if (!SWIG_IsOK(res2)) {
44850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44851 }
44852 if (!argp2) {
44853 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44854 }
44855 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44856 {
44857 PyThreadState* __tstate = wxPyBeginAllowThreads();
44858 (arg1)->Command(*arg2);
44859 wxPyEndAllowThreads(__tstate);
44860 if (PyErr_Occurred()) SWIG_fail;
44861 }
44862 resultobj = SWIG_Py_Void();
44863 return resultobj;
44864 fail:
44865 return NULL;
44866 }
44867
44868
44869 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44870 PyObject *resultobj = 0;
44871 wxControl *arg1 = (wxControl *) 0 ;
44872 wxString result;
44873 void *argp1 = 0 ;
44874 int res1 = 0 ;
44875 PyObject *swig_obj[1] ;
44876
44877 if (!args) SWIG_fail;
44878 swig_obj[0] = args;
44879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44880 if (!SWIG_IsOK(res1)) {
44881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44882 }
44883 arg1 = reinterpret_cast< wxControl * >(argp1);
44884 {
44885 PyThreadState* __tstate = wxPyBeginAllowThreads();
44886 result = (arg1)->GetLabel();
44887 wxPyEndAllowThreads(__tstate);
44888 if (PyErr_Occurred()) SWIG_fail;
44889 }
44890 {
44891 #if wxUSE_UNICODE
44892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44893 #else
44894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44895 #endif
44896 }
44897 return resultobj;
44898 fail:
44899 return NULL;
44900 }
44901
44902
44903 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44904 PyObject *resultobj = 0;
44905 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44906 SwigValueWrapper<wxVisualAttributes > result;
44907 int val1 ;
44908 int ecode1 = 0 ;
44909 PyObject * obj0 = 0 ;
44910 char * kwnames[] = {
44911 (char *) "variant", NULL
44912 };
44913
44914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44915 if (obj0) {
44916 ecode1 = SWIG_AsVal_int(obj0, &val1);
44917 if (!SWIG_IsOK(ecode1)) {
44918 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44919 }
44920 arg1 = static_cast< wxWindowVariant >(val1);
44921 }
44922 {
44923 if (!wxPyCheckForApp()) SWIG_fail;
44924 PyThreadState* __tstate = wxPyBeginAllowThreads();
44925 result = wxControl::GetClassDefaultAttributes(arg1);
44926 wxPyEndAllowThreads(__tstate);
44927 if (PyErr_Occurred()) SWIG_fail;
44928 }
44929 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44930 return resultobj;
44931 fail:
44932 return NULL;
44933 }
44934
44935
44936 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44937 PyObject *obj;
44938 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44939 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44940 return SWIG_Py_Void();
44941 }
44942
44943 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44944 return SWIG_Python_InitShadowInstance(args);
44945 }
44946
44947 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44948 PyObject *resultobj = 0;
44949 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44950 wxString *arg2 = 0 ;
44951 PyObject *arg3 = (PyObject *) NULL ;
44952 int result;
44953 void *argp1 = 0 ;
44954 int res1 = 0 ;
44955 bool temp2 = false ;
44956 PyObject * obj0 = 0 ;
44957 PyObject * obj1 = 0 ;
44958 PyObject * obj2 = 0 ;
44959 char * kwnames[] = {
44960 (char *) "self",(char *) "item",(char *) "clientData", NULL
44961 };
44962
44963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44965 if (!SWIG_IsOK(res1)) {
44966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44967 }
44968 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44969 {
44970 arg2 = wxString_in_helper(obj1);
44971 if (arg2 == NULL) SWIG_fail;
44972 temp2 = true;
44973 }
44974 if (obj2) {
44975 arg3 = obj2;
44976 }
44977 {
44978 PyThreadState* __tstate = wxPyBeginAllowThreads();
44979 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44980 wxPyEndAllowThreads(__tstate);
44981 if (PyErr_Occurred()) SWIG_fail;
44982 }
44983 resultobj = SWIG_From_int(static_cast< int >(result));
44984 {
44985 if (temp2)
44986 delete arg2;
44987 }
44988 return resultobj;
44989 fail:
44990 {
44991 if (temp2)
44992 delete arg2;
44993 }
44994 return NULL;
44995 }
44996
44997
44998 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44999 PyObject *resultobj = 0;
45000 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45001 wxArrayString *arg2 = 0 ;
45002 void *argp1 = 0 ;
45003 int res1 = 0 ;
45004 bool temp2 = false ;
45005 PyObject * obj0 = 0 ;
45006 PyObject * obj1 = 0 ;
45007 char * kwnames[] = {
45008 (char *) "self",(char *) "strings", NULL
45009 };
45010
45011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
45012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45013 if (!SWIG_IsOK(res1)) {
45014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45015 }
45016 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45017 {
45018 if (! PySequence_Check(obj1)) {
45019 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
45020 SWIG_fail;
45021 }
45022 arg2 = new wxArrayString;
45023 temp2 = true;
45024 int i, len=PySequence_Length(obj1);
45025 for (i=0; i<len; i++) {
45026 PyObject* item = PySequence_GetItem(obj1, i);
45027 wxString* s = wxString_in_helper(item);
45028 if (PyErr_Occurred()) SWIG_fail;
45029 arg2->Add(*s);
45030 delete s;
45031 Py_DECREF(item);
45032 }
45033 }
45034 {
45035 PyThreadState* __tstate = wxPyBeginAllowThreads();
45036 (arg1)->Append((wxArrayString const &)*arg2);
45037 wxPyEndAllowThreads(__tstate);
45038 if (PyErr_Occurred()) SWIG_fail;
45039 }
45040 resultobj = SWIG_Py_Void();
45041 {
45042 if (temp2) delete arg2;
45043 }
45044 return resultobj;
45045 fail:
45046 {
45047 if (temp2) delete arg2;
45048 }
45049 return NULL;
45050 }
45051
45052
45053 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45054 PyObject *resultobj = 0;
45055 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45056 wxString *arg2 = 0 ;
45057 unsigned int arg3 ;
45058 PyObject *arg4 = (PyObject *) NULL ;
45059 int result;
45060 void *argp1 = 0 ;
45061 int res1 = 0 ;
45062 bool temp2 = false ;
45063 unsigned int val3 ;
45064 int ecode3 = 0 ;
45065 PyObject * obj0 = 0 ;
45066 PyObject * obj1 = 0 ;
45067 PyObject * obj2 = 0 ;
45068 PyObject * obj3 = 0 ;
45069 char * kwnames[] = {
45070 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
45071 };
45072
45073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45075 if (!SWIG_IsOK(res1)) {
45076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45077 }
45078 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45079 {
45080 arg2 = wxString_in_helper(obj1);
45081 if (arg2 == NULL) SWIG_fail;
45082 temp2 = true;
45083 }
45084 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
45085 if (!SWIG_IsOK(ecode3)) {
45086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
45087 }
45088 arg3 = static_cast< unsigned int >(val3);
45089 if (obj3) {
45090 arg4 = obj3;
45091 }
45092 {
45093 PyThreadState* __tstate = wxPyBeginAllowThreads();
45094 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
45095 wxPyEndAllowThreads(__tstate);
45096 if (PyErr_Occurred()) SWIG_fail;
45097 }
45098 resultobj = SWIG_From_int(static_cast< int >(result));
45099 {
45100 if (temp2)
45101 delete arg2;
45102 }
45103 return resultobj;
45104 fail:
45105 {
45106 if (temp2)
45107 delete arg2;
45108 }
45109 return NULL;
45110 }
45111
45112
45113 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45114 PyObject *resultobj = 0;
45115 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45116 void *argp1 = 0 ;
45117 int res1 = 0 ;
45118 PyObject *swig_obj[1] ;
45119
45120 if (!args) SWIG_fail;
45121 swig_obj[0] = args;
45122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45123 if (!SWIG_IsOK(res1)) {
45124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45125 }
45126 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45127 {
45128 PyThreadState* __tstate = wxPyBeginAllowThreads();
45129 (arg1)->Clear();
45130 wxPyEndAllowThreads(__tstate);
45131 if (PyErr_Occurred()) SWIG_fail;
45132 }
45133 resultobj = SWIG_Py_Void();
45134 return resultobj;
45135 fail:
45136 return NULL;
45137 }
45138
45139
45140 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45141 PyObject *resultobj = 0;
45142 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45143 unsigned int arg2 ;
45144 void *argp1 = 0 ;
45145 int res1 = 0 ;
45146 unsigned int val2 ;
45147 int ecode2 = 0 ;
45148 PyObject * obj0 = 0 ;
45149 PyObject * obj1 = 0 ;
45150 char * kwnames[] = {
45151 (char *) "self",(char *) "n", NULL
45152 };
45153
45154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
45155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45156 if (!SWIG_IsOK(res1)) {
45157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45158 }
45159 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45160 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45161 if (!SWIG_IsOK(ecode2)) {
45162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
45163 }
45164 arg2 = static_cast< unsigned int >(val2);
45165 {
45166 PyThreadState* __tstate = wxPyBeginAllowThreads();
45167 (arg1)->Delete(arg2);
45168 wxPyEndAllowThreads(__tstate);
45169 if (PyErr_Occurred()) SWIG_fail;
45170 }
45171 resultobj = SWIG_Py_Void();
45172 return resultobj;
45173 fail:
45174 return NULL;
45175 }
45176
45177
45178 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45179 PyObject *resultobj = 0;
45180 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45181 unsigned int arg2 ;
45182 PyObject *result = 0 ;
45183 void *argp1 = 0 ;
45184 int res1 = 0 ;
45185 unsigned int val2 ;
45186 int ecode2 = 0 ;
45187 PyObject * obj0 = 0 ;
45188 PyObject * obj1 = 0 ;
45189 char * kwnames[] = {
45190 (char *) "self",(char *) "n", NULL
45191 };
45192
45193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
45194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45195 if (!SWIG_IsOK(res1)) {
45196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45197 }
45198 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45199 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45200 if (!SWIG_IsOK(ecode2)) {
45201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45202 }
45203 arg2 = static_cast< unsigned int >(val2);
45204 {
45205 PyThreadState* __tstate = wxPyBeginAllowThreads();
45206 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
45207 wxPyEndAllowThreads(__tstate);
45208 if (PyErr_Occurred()) SWIG_fail;
45209 }
45210 resultobj = result;
45211 return resultobj;
45212 fail:
45213 return NULL;
45214 }
45215
45216
45217 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45218 PyObject *resultobj = 0;
45219 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45220 unsigned int arg2 ;
45221 PyObject *arg3 = (PyObject *) 0 ;
45222 void *argp1 = 0 ;
45223 int res1 = 0 ;
45224 unsigned int val2 ;
45225 int ecode2 = 0 ;
45226 PyObject * obj0 = 0 ;
45227 PyObject * obj1 = 0 ;
45228 PyObject * obj2 = 0 ;
45229 char * kwnames[] = {
45230 (char *) "self",(char *) "n",(char *) "clientData", NULL
45231 };
45232
45233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45235 if (!SWIG_IsOK(res1)) {
45236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45237 }
45238 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45239 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45240 if (!SWIG_IsOK(ecode2)) {
45241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
45242 }
45243 arg2 = static_cast< unsigned int >(val2);
45244 arg3 = obj2;
45245 {
45246 PyThreadState* __tstate = wxPyBeginAllowThreads();
45247 wxItemContainer_SetClientData(arg1,arg2,arg3);
45248 wxPyEndAllowThreads(__tstate);
45249 if (PyErr_Occurred()) SWIG_fail;
45250 }
45251 resultobj = SWIG_Py_Void();
45252 return resultobj;
45253 fail:
45254 return NULL;
45255 }
45256
45257
45258 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45259 PyObject *resultobj = 0;
45260 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45261 unsigned int result;
45262 void *argp1 = 0 ;
45263 int res1 = 0 ;
45264 PyObject *swig_obj[1] ;
45265
45266 if (!args) SWIG_fail;
45267 swig_obj[0] = args;
45268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45269 if (!SWIG_IsOK(res1)) {
45270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45271 }
45272 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45273 {
45274 PyThreadState* __tstate = wxPyBeginAllowThreads();
45275 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
45276 wxPyEndAllowThreads(__tstate);
45277 if (PyErr_Occurred()) SWIG_fail;
45278 }
45279 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
45280 return resultobj;
45281 fail:
45282 return NULL;
45283 }
45284
45285
45286 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45287 PyObject *resultobj = 0;
45288 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45289 bool result;
45290 void *argp1 = 0 ;
45291 int res1 = 0 ;
45292 PyObject *swig_obj[1] ;
45293
45294 if (!args) SWIG_fail;
45295 swig_obj[0] = args;
45296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45297 if (!SWIG_IsOK(res1)) {
45298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45299 }
45300 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45301 {
45302 PyThreadState* __tstate = wxPyBeginAllowThreads();
45303 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
45304 wxPyEndAllowThreads(__tstate);
45305 if (PyErr_Occurred()) SWIG_fail;
45306 }
45307 {
45308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45309 }
45310 return resultobj;
45311 fail:
45312 return NULL;
45313 }
45314
45315
45316 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45317 PyObject *resultobj = 0;
45318 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45319 unsigned int arg2 ;
45320 wxString result;
45321 void *argp1 = 0 ;
45322 int res1 = 0 ;
45323 unsigned int val2 ;
45324 int ecode2 = 0 ;
45325 PyObject * obj0 = 0 ;
45326 PyObject * obj1 = 0 ;
45327 char * kwnames[] = {
45328 (char *) "self",(char *) "n", NULL
45329 };
45330
45331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
45332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45333 if (!SWIG_IsOK(res1)) {
45334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45335 }
45336 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45337 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45338 if (!SWIG_IsOK(ecode2)) {
45339 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
45340 }
45341 arg2 = static_cast< unsigned int >(val2);
45342 {
45343 PyThreadState* __tstate = wxPyBeginAllowThreads();
45344 result = ((wxItemContainer const *)arg1)->GetString(arg2);
45345 wxPyEndAllowThreads(__tstate);
45346 if (PyErr_Occurred()) SWIG_fail;
45347 }
45348 {
45349 #if wxUSE_UNICODE
45350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45351 #else
45352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45353 #endif
45354 }
45355 return resultobj;
45356 fail:
45357 return NULL;
45358 }
45359
45360
45361 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45362 PyObject *resultobj = 0;
45363 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45364 wxArrayString result;
45365 void *argp1 = 0 ;
45366 int res1 = 0 ;
45367 PyObject *swig_obj[1] ;
45368
45369 if (!args) SWIG_fail;
45370 swig_obj[0] = args;
45371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45372 if (!SWIG_IsOK(res1)) {
45373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45374 }
45375 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45376 {
45377 PyThreadState* __tstate = wxPyBeginAllowThreads();
45378 result = ((wxItemContainer const *)arg1)->GetStrings();
45379 wxPyEndAllowThreads(__tstate);
45380 if (PyErr_Occurred()) SWIG_fail;
45381 }
45382 {
45383 resultobj = wxArrayString2PyList_helper(result);
45384 }
45385 return resultobj;
45386 fail:
45387 return NULL;
45388 }
45389
45390
45391 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45392 PyObject *resultobj = 0;
45393 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45394 unsigned int arg2 ;
45395 wxString *arg3 = 0 ;
45396 void *argp1 = 0 ;
45397 int res1 = 0 ;
45398 unsigned int val2 ;
45399 int ecode2 = 0 ;
45400 bool temp3 = false ;
45401 PyObject * obj0 = 0 ;
45402 PyObject * obj1 = 0 ;
45403 PyObject * obj2 = 0 ;
45404 char * kwnames[] = {
45405 (char *) "self",(char *) "n",(char *) "s", NULL
45406 };
45407
45408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45410 if (!SWIG_IsOK(res1)) {
45411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45412 }
45413 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45414 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
45415 if (!SWIG_IsOK(ecode2)) {
45416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
45417 }
45418 arg2 = static_cast< unsigned int >(val2);
45419 {
45420 arg3 = wxString_in_helper(obj2);
45421 if (arg3 == NULL) SWIG_fail;
45422 temp3 = true;
45423 }
45424 {
45425 PyThreadState* __tstate = wxPyBeginAllowThreads();
45426 (arg1)->SetString(arg2,(wxString const &)*arg3);
45427 wxPyEndAllowThreads(__tstate);
45428 if (PyErr_Occurred()) SWIG_fail;
45429 }
45430 resultobj = SWIG_Py_Void();
45431 {
45432 if (temp3)
45433 delete arg3;
45434 }
45435 return resultobj;
45436 fail:
45437 {
45438 if (temp3)
45439 delete arg3;
45440 }
45441 return NULL;
45442 }
45443
45444
45445 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45446 PyObject *resultobj = 0;
45447 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45448 wxString *arg2 = 0 ;
45449 int result;
45450 void *argp1 = 0 ;
45451 int res1 = 0 ;
45452 bool temp2 = false ;
45453 PyObject * obj0 = 0 ;
45454 PyObject * obj1 = 0 ;
45455 char * kwnames[] = {
45456 (char *) "self",(char *) "s", NULL
45457 };
45458
45459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
45460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45461 if (!SWIG_IsOK(res1)) {
45462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45463 }
45464 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45465 {
45466 arg2 = wxString_in_helper(obj1);
45467 if (arg2 == NULL) SWIG_fail;
45468 temp2 = true;
45469 }
45470 {
45471 PyThreadState* __tstate = wxPyBeginAllowThreads();
45472 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
45473 wxPyEndAllowThreads(__tstate);
45474 if (PyErr_Occurred()) SWIG_fail;
45475 }
45476 resultobj = SWIG_From_int(static_cast< int >(result));
45477 {
45478 if (temp2)
45479 delete arg2;
45480 }
45481 return resultobj;
45482 fail:
45483 {
45484 if (temp2)
45485 delete arg2;
45486 }
45487 return NULL;
45488 }
45489
45490
45491 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45492 PyObject *resultobj = 0;
45493 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45494 int arg2 ;
45495 void *argp1 = 0 ;
45496 int res1 = 0 ;
45497 int val2 ;
45498 int ecode2 = 0 ;
45499 PyObject * obj0 = 0 ;
45500 PyObject * obj1 = 0 ;
45501 char * kwnames[] = {
45502 (char *) "self",(char *) "n", NULL
45503 };
45504
45505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45507 if (!SWIG_IsOK(res1)) {
45508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45509 }
45510 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45511 ecode2 = SWIG_AsVal_int(obj1, &val2);
45512 if (!SWIG_IsOK(ecode2)) {
45513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
45514 }
45515 arg2 = static_cast< int >(val2);
45516 {
45517 PyThreadState* __tstate = wxPyBeginAllowThreads();
45518 (arg1)->SetSelection(arg2);
45519 wxPyEndAllowThreads(__tstate);
45520 if (PyErr_Occurred()) SWIG_fail;
45521 }
45522 resultobj = SWIG_Py_Void();
45523 return resultobj;
45524 fail:
45525 return NULL;
45526 }
45527
45528
45529 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45530 PyObject *resultobj = 0;
45531 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45532 int result;
45533 void *argp1 = 0 ;
45534 int res1 = 0 ;
45535 PyObject *swig_obj[1] ;
45536
45537 if (!args) SWIG_fail;
45538 swig_obj[0] = args;
45539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45540 if (!SWIG_IsOK(res1)) {
45541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45542 }
45543 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45544 {
45545 PyThreadState* __tstate = wxPyBeginAllowThreads();
45546 result = (int)((wxItemContainer const *)arg1)->GetSelection();
45547 wxPyEndAllowThreads(__tstate);
45548 if (PyErr_Occurred()) SWIG_fail;
45549 }
45550 resultobj = SWIG_From_int(static_cast< int >(result));
45551 return resultobj;
45552 fail:
45553 return NULL;
45554 }
45555
45556
45557 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45558 PyObject *resultobj = 0;
45559 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45560 wxString *arg2 = 0 ;
45561 bool result;
45562 void *argp1 = 0 ;
45563 int res1 = 0 ;
45564 bool temp2 = false ;
45565 PyObject * obj0 = 0 ;
45566 PyObject * obj1 = 0 ;
45567 char * kwnames[] = {
45568 (char *) "self",(char *) "s", NULL
45569 };
45570
45571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
45572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45573 if (!SWIG_IsOK(res1)) {
45574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45575 }
45576 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45577 {
45578 arg2 = wxString_in_helper(obj1);
45579 if (arg2 == NULL) SWIG_fail;
45580 temp2 = true;
45581 }
45582 {
45583 PyThreadState* __tstate = wxPyBeginAllowThreads();
45584 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
45585 wxPyEndAllowThreads(__tstate);
45586 if (PyErr_Occurred()) SWIG_fail;
45587 }
45588 {
45589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45590 }
45591 {
45592 if (temp2)
45593 delete arg2;
45594 }
45595 return resultobj;
45596 fail:
45597 {
45598 if (temp2)
45599 delete arg2;
45600 }
45601 return NULL;
45602 }
45603
45604
45605 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45606 PyObject *resultobj = 0;
45607 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45608 wxString result;
45609 void *argp1 = 0 ;
45610 int res1 = 0 ;
45611 PyObject *swig_obj[1] ;
45612
45613 if (!args) SWIG_fail;
45614 swig_obj[0] = args;
45615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45616 if (!SWIG_IsOK(res1)) {
45617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
45618 }
45619 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45620 {
45621 PyThreadState* __tstate = wxPyBeginAllowThreads();
45622 result = ((wxItemContainer const *)arg1)->GetStringSelection();
45623 wxPyEndAllowThreads(__tstate);
45624 if (PyErr_Occurred()) SWIG_fail;
45625 }
45626 {
45627 #if wxUSE_UNICODE
45628 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45629 #else
45630 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45631 #endif
45632 }
45633 return resultobj;
45634 fail:
45635 return NULL;
45636 }
45637
45638
45639 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45640 PyObject *resultobj = 0;
45641 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
45642 int arg2 ;
45643 void *argp1 = 0 ;
45644 int res1 = 0 ;
45645 int val2 ;
45646 int ecode2 = 0 ;
45647 PyObject * obj0 = 0 ;
45648 PyObject * obj1 = 0 ;
45649 char * kwnames[] = {
45650 (char *) "self",(char *) "n", NULL
45651 };
45652
45653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
45654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
45655 if (!SWIG_IsOK(res1)) {
45656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
45657 }
45658 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
45659 ecode2 = SWIG_AsVal_int(obj1, &val2);
45660 if (!SWIG_IsOK(ecode2)) {
45661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
45662 }
45663 arg2 = static_cast< int >(val2);
45664 {
45665 PyThreadState* __tstate = wxPyBeginAllowThreads();
45666 (arg1)->Select(arg2);
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 *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45678 PyObject *obj;
45679 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45680 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
45681 return SWIG_Py_Void();
45682 }
45683
45684 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45685 PyObject *obj;
45686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45687 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
45688 return SWIG_Py_Void();
45689 }
45690
45691 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45692 PyObject *resultobj = 0;
45693 wxSizerItem *result = 0 ;
45694
45695 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45696 {
45697 PyThreadState* __tstate = wxPyBeginAllowThreads();
45698 result = (wxSizerItem *)new wxSizerItem();
45699 wxPyEndAllowThreads(__tstate);
45700 if (PyErr_Occurred()) SWIG_fail;
45701 }
45702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45703 return resultobj;
45704 fail:
45705 return NULL;
45706 }
45707
45708
45709 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45710 PyObject *resultobj = 0;
45711 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45712 void *argp1 = 0 ;
45713 int res1 = 0 ;
45714 PyObject *swig_obj[1] ;
45715
45716 if (!args) SWIG_fail;
45717 swig_obj[0] = args;
45718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45719 if (!SWIG_IsOK(res1)) {
45720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45721 }
45722 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45723 {
45724 PyThreadState* __tstate = wxPyBeginAllowThreads();
45725 delete arg1;
45726
45727 wxPyEndAllowThreads(__tstate);
45728 if (PyErr_Occurred()) SWIG_fail;
45729 }
45730 resultobj = SWIG_Py_Void();
45731 return resultobj;
45732 fail:
45733 return NULL;
45734 }
45735
45736
45737 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45738 PyObject *resultobj = 0;
45739 wxWindow *arg1 = (wxWindow *) 0 ;
45740 int arg2 ;
45741 int arg3 ;
45742 int arg4 ;
45743 PyObject *arg5 = (PyObject *) NULL ;
45744 wxSizerItem *result = 0 ;
45745 void *argp1 = 0 ;
45746 int res1 = 0 ;
45747 int val2 ;
45748 int ecode2 = 0 ;
45749 int val3 ;
45750 int ecode3 = 0 ;
45751 int val4 ;
45752 int ecode4 = 0 ;
45753 PyObject * obj0 = 0 ;
45754 PyObject * obj1 = 0 ;
45755 PyObject * obj2 = 0 ;
45756 PyObject * obj3 = 0 ;
45757 PyObject * obj4 = 0 ;
45758 char * kwnames[] = {
45759 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45760 };
45761
45762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45764 if (!SWIG_IsOK(res1)) {
45765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45766 }
45767 arg1 = reinterpret_cast< wxWindow * >(argp1);
45768 ecode2 = SWIG_AsVal_int(obj1, &val2);
45769 if (!SWIG_IsOK(ecode2)) {
45770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45771 }
45772 arg2 = static_cast< int >(val2);
45773 ecode3 = SWIG_AsVal_int(obj2, &val3);
45774 if (!SWIG_IsOK(ecode3)) {
45775 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45776 }
45777 arg3 = static_cast< int >(val3);
45778 ecode4 = SWIG_AsVal_int(obj3, &val4);
45779 if (!SWIG_IsOK(ecode4)) {
45780 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45781 }
45782 arg4 = static_cast< int >(val4);
45783 if (obj4) {
45784 arg5 = obj4;
45785 }
45786 {
45787 PyThreadState* __tstate = wxPyBeginAllowThreads();
45788 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45789 wxPyEndAllowThreads(__tstate);
45790 if (PyErr_Occurred()) SWIG_fail;
45791 }
45792 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45793 return resultobj;
45794 fail:
45795 return NULL;
45796 }
45797
45798
45799 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45800 PyObject *resultobj = 0;
45801 int arg1 ;
45802 int arg2 ;
45803 int arg3 ;
45804 int arg4 ;
45805 int arg5 ;
45806 PyObject *arg6 = (PyObject *) NULL ;
45807 wxSizerItem *result = 0 ;
45808 int val1 ;
45809 int ecode1 = 0 ;
45810 int val2 ;
45811 int ecode2 = 0 ;
45812 int val3 ;
45813 int ecode3 = 0 ;
45814 int val4 ;
45815 int ecode4 = 0 ;
45816 int val5 ;
45817 int ecode5 = 0 ;
45818 PyObject * obj0 = 0 ;
45819 PyObject * obj1 = 0 ;
45820 PyObject * obj2 = 0 ;
45821 PyObject * obj3 = 0 ;
45822 PyObject * obj4 = 0 ;
45823 PyObject * obj5 = 0 ;
45824 char * kwnames[] = {
45825 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45826 };
45827
45828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45829 ecode1 = SWIG_AsVal_int(obj0, &val1);
45830 if (!SWIG_IsOK(ecode1)) {
45831 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45832 }
45833 arg1 = static_cast< int >(val1);
45834 ecode2 = SWIG_AsVal_int(obj1, &val2);
45835 if (!SWIG_IsOK(ecode2)) {
45836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45837 }
45838 arg2 = static_cast< int >(val2);
45839 ecode3 = SWIG_AsVal_int(obj2, &val3);
45840 if (!SWIG_IsOK(ecode3)) {
45841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45842 }
45843 arg3 = static_cast< int >(val3);
45844 ecode4 = SWIG_AsVal_int(obj3, &val4);
45845 if (!SWIG_IsOK(ecode4)) {
45846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45847 }
45848 arg4 = static_cast< int >(val4);
45849 ecode5 = SWIG_AsVal_int(obj4, &val5);
45850 if (!SWIG_IsOK(ecode5)) {
45851 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45852 }
45853 arg5 = static_cast< int >(val5);
45854 if (obj5) {
45855 arg6 = obj5;
45856 }
45857 {
45858 PyThreadState* __tstate = wxPyBeginAllowThreads();
45859 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
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_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45871 PyObject *resultobj = 0;
45872 wxSizer *arg1 = (wxSizer *) 0 ;
45873 int arg2 ;
45874 int arg3 ;
45875 int arg4 ;
45876 PyObject *arg5 = (PyObject *) NULL ;
45877 wxSizerItem *result = 0 ;
45878 int res1 = 0 ;
45879 int val2 ;
45880 int ecode2 = 0 ;
45881 int val3 ;
45882 int ecode3 = 0 ;
45883 int val4 ;
45884 int ecode4 = 0 ;
45885 PyObject * obj0 = 0 ;
45886 PyObject * obj1 = 0 ;
45887 PyObject * obj2 = 0 ;
45888 PyObject * obj3 = 0 ;
45889 PyObject * obj4 = 0 ;
45890 char * kwnames[] = {
45891 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45892 };
45893
45894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45895 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45896 if (!SWIG_IsOK(res1)) {
45897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45898 }
45899 ecode2 = SWIG_AsVal_int(obj1, &val2);
45900 if (!SWIG_IsOK(ecode2)) {
45901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45902 }
45903 arg2 = static_cast< int >(val2);
45904 ecode3 = SWIG_AsVal_int(obj2, &val3);
45905 if (!SWIG_IsOK(ecode3)) {
45906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45907 }
45908 arg3 = static_cast< int >(val3);
45909 ecode4 = SWIG_AsVal_int(obj3, &val4);
45910 if (!SWIG_IsOK(ecode4)) {
45911 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45912 }
45913 arg4 = static_cast< int >(val4);
45914 if (obj4) {
45915 arg5 = obj4;
45916 }
45917 {
45918 PyThreadState* __tstate = wxPyBeginAllowThreads();
45919 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45920 wxPyEndAllowThreads(__tstate);
45921 if (PyErr_Occurred()) SWIG_fail;
45922 }
45923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45924 return resultobj;
45925 fail:
45926 return NULL;
45927 }
45928
45929
45930 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45931 PyObject *resultobj = 0;
45932 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45933 void *argp1 = 0 ;
45934 int res1 = 0 ;
45935 PyObject *swig_obj[1] ;
45936
45937 if (!args) SWIG_fail;
45938 swig_obj[0] = args;
45939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45940 if (!SWIG_IsOK(res1)) {
45941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45942 }
45943 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45944 {
45945 PyThreadState* __tstate = wxPyBeginAllowThreads();
45946 (arg1)->DeleteWindows();
45947 wxPyEndAllowThreads(__tstate);
45948 if (PyErr_Occurred()) SWIG_fail;
45949 }
45950 resultobj = SWIG_Py_Void();
45951 return resultobj;
45952 fail:
45953 return NULL;
45954 }
45955
45956
45957 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45958 PyObject *resultobj = 0;
45959 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45960 void *argp1 = 0 ;
45961 int res1 = 0 ;
45962 PyObject *swig_obj[1] ;
45963
45964 if (!args) SWIG_fail;
45965 swig_obj[0] = args;
45966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45967 if (!SWIG_IsOK(res1)) {
45968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45969 }
45970 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45971 {
45972 PyThreadState* __tstate = wxPyBeginAllowThreads();
45973 (arg1)->DetachSizer();
45974 wxPyEndAllowThreads(__tstate);
45975 if (PyErr_Occurred()) SWIG_fail;
45976 }
45977 resultobj = SWIG_Py_Void();
45978 return resultobj;
45979 fail:
45980 return NULL;
45981 }
45982
45983
45984 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45985 PyObject *resultobj = 0;
45986 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45987 wxSize result;
45988 void *argp1 = 0 ;
45989 int res1 = 0 ;
45990 PyObject *swig_obj[1] ;
45991
45992 if (!args) SWIG_fail;
45993 swig_obj[0] = args;
45994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45995 if (!SWIG_IsOK(res1)) {
45996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45997 }
45998 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45999 {
46000 PyThreadState* __tstate = wxPyBeginAllowThreads();
46001 result = (arg1)->GetSize();
46002 wxPyEndAllowThreads(__tstate);
46003 if (PyErr_Occurred()) SWIG_fail;
46004 }
46005 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46006 return resultobj;
46007 fail:
46008 return NULL;
46009 }
46010
46011
46012 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46013 PyObject *resultobj = 0;
46014 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46015 wxSize result;
46016 void *argp1 = 0 ;
46017 int res1 = 0 ;
46018 PyObject *swig_obj[1] ;
46019
46020 if (!args) SWIG_fail;
46021 swig_obj[0] = args;
46022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46023 if (!SWIG_IsOK(res1)) {
46024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46025 }
46026 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46027 {
46028 PyThreadState* __tstate = wxPyBeginAllowThreads();
46029 result = (arg1)->CalcMin();
46030 wxPyEndAllowThreads(__tstate);
46031 if (PyErr_Occurred()) SWIG_fail;
46032 }
46033 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46034 return resultobj;
46035 fail:
46036 return NULL;
46037 }
46038
46039
46040 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46041 PyObject *resultobj = 0;
46042 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46043 wxPoint *arg2 = 0 ;
46044 wxSize *arg3 = 0 ;
46045 void *argp1 = 0 ;
46046 int res1 = 0 ;
46047 wxPoint temp2 ;
46048 wxSize temp3 ;
46049 PyObject * obj0 = 0 ;
46050 PyObject * obj1 = 0 ;
46051 PyObject * obj2 = 0 ;
46052 char * kwnames[] = {
46053 (char *) "self",(char *) "pos",(char *) "size", NULL
46054 };
46055
46056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46058 if (!SWIG_IsOK(res1)) {
46059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46060 }
46061 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46062 {
46063 arg2 = &temp2;
46064 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
46065 }
46066 {
46067 arg3 = &temp3;
46068 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46069 }
46070 {
46071 PyThreadState* __tstate = wxPyBeginAllowThreads();
46072 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
46073 wxPyEndAllowThreads(__tstate);
46074 if (PyErr_Occurred()) SWIG_fail;
46075 }
46076 resultobj = SWIG_Py_Void();
46077 return resultobj;
46078 fail:
46079 return NULL;
46080 }
46081
46082
46083 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46084 PyObject *resultobj = 0;
46085 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46086 wxSize result;
46087 void *argp1 = 0 ;
46088 int res1 = 0 ;
46089 PyObject *swig_obj[1] ;
46090
46091 if (!args) SWIG_fail;
46092 swig_obj[0] = args;
46093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46094 if (!SWIG_IsOK(res1)) {
46095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46096 }
46097 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46098 {
46099 PyThreadState* __tstate = wxPyBeginAllowThreads();
46100 result = (arg1)->GetMinSize();
46101 wxPyEndAllowThreads(__tstate);
46102 if (PyErr_Occurred()) SWIG_fail;
46103 }
46104 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46105 return resultobj;
46106 fail:
46107 return NULL;
46108 }
46109
46110
46111 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46112 PyObject *resultobj = 0;
46113 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46114 wxSize result;
46115 void *argp1 = 0 ;
46116 int res1 = 0 ;
46117 PyObject *swig_obj[1] ;
46118
46119 if (!args) SWIG_fail;
46120 swig_obj[0] = args;
46121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46122 if (!SWIG_IsOK(res1)) {
46123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
46124 }
46125 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46126 {
46127 PyThreadState* __tstate = wxPyBeginAllowThreads();
46128 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
46129 wxPyEndAllowThreads(__tstate);
46130 if (PyErr_Occurred()) SWIG_fail;
46131 }
46132 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46133 return resultobj;
46134 fail:
46135 return NULL;
46136 }
46137
46138
46139 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46140 PyObject *resultobj = 0;
46141 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46142 int arg2 ;
46143 int arg3 ;
46144 void *argp1 = 0 ;
46145 int res1 = 0 ;
46146 int val2 ;
46147 int ecode2 = 0 ;
46148 int val3 ;
46149 int ecode3 = 0 ;
46150 PyObject * obj0 = 0 ;
46151 PyObject * obj1 = 0 ;
46152 PyObject * obj2 = 0 ;
46153 char * kwnames[] = {
46154 (char *) "self",(char *) "x",(char *) "y", NULL
46155 };
46156
46157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46159 if (!SWIG_IsOK(res1)) {
46160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46161 }
46162 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46163 ecode2 = SWIG_AsVal_int(obj1, &val2);
46164 if (!SWIG_IsOK(ecode2)) {
46165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
46166 }
46167 arg2 = static_cast< int >(val2);
46168 ecode3 = SWIG_AsVal_int(obj2, &val3);
46169 if (!SWIG_IsOK(ecode3)) {
46170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
46171 }
46172 arg3 = static_cast< int >(val3);
46173 {
46174 PyThreadState* __tstate = wxPyBeginAllowThreads();
46175 (arg1)->SetInitSize(arg2,arg3);
46176 wxPyEndAllowThreads(__tstate);
46177 if (PyErr_Occurred()) SWIG_fail;
46178 }
46179 resultobj = SWIG_Py_Void();
46180 return resultobj;
46181 fail:
46182 return NULL;
46183 }
46184
46185
46186 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46187 PyObject *resultobj = 0;
46188 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46189 int arg2 ;
46190 int arg3 ;
46191 void *argp1 = 0 ;
46192 int res1 = 0 ;
46193 int val2 ;
46194 int ecode2 = 0 ;
46195 int val3 ;
46196 int ecode3 = 0 ;
46197 PyObject * obj0 = 0 ;
46198 PyObject * obj1 = 0 ;
46199 PyObject * obj2 = 0 ;
46200 char * kwnames[] = {
46201 (char *) "self",(char *) "width",(char *) "height", NULL
46202 };
46203
46204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46206 if (!SWIG_IsOK(res1)) {
46207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46208 }
46209 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46210 ecode2 = SWIG_AsVal_int(obj1, &val2);
46211 if (!SWIG_IsOK(ecode2)) {
46212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
46213 }
46214 arg2 = static_cast< int >(val2);
46215 ecode3 = SWIG_AsVal_int(obj2, &val3);
46216 if (!SWIG_IsOK(ecode3)) {
46217 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
46218 }
46219 arg3 = static_cast< int >(val3);
46220 {
46221 PyThreadState* __tstate = wxPyBeginAllowThreads();
46222 (arg1)->SetRatio(arg2,arg3);
46223 wxPyEndAllowThreads(__tstate);
46224 if (PyErr_Occurred()) SWIG_fail;
46225 }
46226 resultobj = SWIG_Py_Void();
46227 return resultobj;
46228 fail:
46229 return NULL;
46230 }
46231
46232
46233 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46234 PyObject *resultobj = 0;
46235 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46236 wxSize *arg2 = 0 ;
46237 void *argp1 = 0 ;
46238 int res1 = 0 ;
46239 wxSize temp2 ;
46240 PyObject * obj0 = 0 ;
46241 PyObject * obj1 = 0 ;
46242 char * kwnames[] = {
46243 (char *) "self",(char *) "size", NULL
46244 };
46245
46246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
46247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46248 if (!SWIG_IsOK(res1)) {
46249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46250 }
46251 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46252 {
46253 arg2 = &temp2;
46254 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46255 }
46256 {
46257 PyThreadState* __tstate = wxPyBeginAllowThreads();
46258 (arg1)->SetRatio((wxSize const &)*arg2);
46259 wxPyEndAllowThreads(__tstate);
46260 if (PyErr_Occurred()) SWIG_fail;
46261 }
46262 resultobj = SWIG_Py_Void();
46263 return resultobj;
46264 fail:
46265 return NULL;
46266 }
46267
46268
46269 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46270 PyObject *resultobj = 0;
46271 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46272 float arg2 ;
46273 void *argp1 = 0 ;
46274 int res1 = 0 ;
46275 float val2 ;
46276 int ecode2 = 0 ;
46277 PyObject * obj0 = 0 ;
46278 PyObject * obj1 = 0 ;
46279 char * kwnames[] = {
46280 (char *) "self",(char *) "ratio", NULL
46281 };
46282
46283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
46284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46285 if (!SWIG_IsOK(res1)) {
46286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46287 }
46288 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46289 ecode2 = SWIG_AsVal_float(obj1, &val2);
46290 if (!SWIG_IsOK(ecode2)) {
46291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
46292 }
46293 arg2 = static_cast< float >(val2);
46294 {
46295 PyThreadState* __tstate = wxPyBeginAllowThreads();
46296 (arg1)->SetRatio(arg2);
46297 wxPyEndAllowThreads(__tstate);
46298 if (PyErr_Occurred()) SWIG_fail;
46299 }
46300 resultobj = SWIG_Py_Void();
46301 return resultobj;
46302 fail:
46303 return NULL;
46304 }
46305
46306
46307 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46308 PyObject *resultobj = 0;
46309 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46310 float result;
46311 void *argp1 = 0 ;
46312 int res1 = 0 ;
46313 PyObject *swig_obj[1] ;
46314
46315 if (!args) SWIG_fail;
46316 swig_obj[0] = args;
46317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46318 if (!SWIG_IsOK(res1)) {
46319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46320 }
46321 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46322 {
46323 PyThreadState* __tstate = wxPyBeginAllowThreads();
46324 result = (float)(arg1)->GetRatio();
46325 wxPyEndAllowThreads(__tstate);
46326 if (PyErr_Occurred()) SWIG_fail;
46327 }
46328 resultobj = SWIG_From_float(static_cast< float >(result));
46329 return resultobj;
46330 fail:
46331 return NULL;
46332 }
46333
46334
46335 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46336 PyObject *resultobj = 0;
46337 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46338 wxRect result;
46339 void *argp1 = 0 ;
46340 int res1 = 0 ;
46341 PyObject *swig_obj[1] ;
46342
46343 if (!args) SWIG_fail;
46344 swig_obj[0] = args;
46345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46346 if (!SWIG_IsOK(res1)) {
46347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46348 }
46349 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46350 {
46351 PyThreadState* __tstate = wxPyBeginAllowThreads();
46352 result = (arg1)->GetRect();
46353 wxPyEndAllowThreads(__tstate);
46354 if (PyErr_Occurred()) SWIG_fail;
46355 }
46356 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
46357 return resultobj;
46358 fail:
46359 return NULL;
46360 }
46361
46362
46363 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(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_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46376 }
46377 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46378 {
46379 PyThreadState* __tstate = wxPyBeginAllowThreads();
46380 result = (bool)(arg1)->IsWindow();
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_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46394 PyObject *resultobj = 0;
46395 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46396 bool result;
46397 void *argp1 = 0 ;
46398 int res1 = 0 ;
46399 PyObject *swig_obj[1] ;
46400
46401 if (!args) SWIG_fail;
46402 swig_obj[0] = args;
46403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46404 if (!SWIG_IsOK(res1)) {
46405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46406 }
46407 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46408 {
46409 PyThreadState* __tstate = wxPyBeginAllowThreads();
46410 result = (bool)(arg1)->IsSizer();
46411 wxPyEndAllowThreads(__tstate);
46412 if (PyErr_Occurred()) SWIG_fail;
46413 }
46414 {
46415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46416 }
46417 return resultobj;
46418 fail:
46419 return NULL;
46420 }
46421
46422
46423 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46424 PyObject *resultobj = 0;
46425 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46426 bool result;
46427 void *argp1 = 0 ;
46428 int res1 = 0 ;
46429 PyObject *swig_obj[1] ;
46430
46431 if (!args) SWIG_fail;
46432 swig_obj[0] = args;
46433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46434 if (!SWIG_IsOK(res1)) {
46435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46436 }
46437 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46438 {
46439 PyThreadState* __tstate = wxPyBeginAllowThreads();
46440 result = (bool)(arg1)->IsSpacer();
46441 wxPyEndAllowThreads(__tstate);
46442 if (PyErr_Occurred()) SWIG_fail;
46443 }
46444 {
46445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46446 }
46447 return resultobj;
46448 fail:
46449 return NULL;
46450 }
46451
46452
46453 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46454 PyObject *resultobj = 0;
46455 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46456 int arg2 ;
46457 void *argp1 = 0 ;
46458 int res1 = 0 ;
46459 int val2 ;
46460 int ecode2 = 0 ;
46461 PyObject * obj0 = 0 ;
46462 PyObject * obj1 = 0 ;
46463 char * kwnames[] = {
46464 (char *) "self",(char *) "proportion", NULL
46465 };
46466
46467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
46468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46469 if (!SWIG_IsOK(res1)) {
46470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46471 }
46472 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46473 ecode2 = SWIG_AsVal_int(obj1, &val2);
46474 if (!SWIG_IsOK(ecode2)) {
46475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
46476 }
46477 arg2 = static_cast< int >(val2);
46478 {
46479 PyThreadState* __tstate = wxPyBeginAllowThreads();
46480 (arg1)->SetProportion(arg2);
46481 wxPyEndAllowThreads(__tstate);
46482 if (PyErr_Occurred()) SWIG_fail;
46483 }
46484 resultobj = SWIG_Py_Void();
46485 return resultobj;
46486 fail:
46487 return NULL;
46488 }
46489
46490
46491 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46492 PyObject *resultobj = 0;
46493 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46494 int result;
46495 void *argp1 = 0 ;
46496 int res1 = 0 ;
46497 PyObject *swig_obj[1] ;
46498
46499 if (!args) SWIG_fail;
46500 swig_obj[0] = args;
46501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46502 if (!SWIG_IsOK(res1)) {
46503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46504 }
46505 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46506 {
46507 PyThreadState* __tstate = wxPyBeginAllowThreads();
46508 result = (int)(arg1)->GetProportion();
46509 wxPyEndAllowThreads(__tstate);
46510 if (PyErr_Occurred()) SWIG_fail;
46511 }
46512 resultobj = SWIG_From_int(static_cast< int >(result));
46513 return resultobj;
46514 fail:
46515 return NULL;
46516 }
46517
46518
46519 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46520 PyObject *resultobj = 0;
46521 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46522 int arg2 ;
46523 void *argp1 = 0 ;
46524 int res1 = 0 ;
46525 int val2 ;
46526 int ecode2 = 0 ;
46527 PyObject * obj0 = 0 ;
46528 PyObject * obj1 = 0 ;
46529 char * kwnames[] = {
46530 (char *) "self",(char *) "flag", NULL
46531 };
46532
46533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
46534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46535 if (!SWIG_IsOK(res1)) {
46536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46537 }
46538 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46539 ecode2 = SWIG_AsVal_int(obj1, &val2);
46540 if (!SWIG_IsOK(ecode2)) {
46541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
46542 }
46543 arg2 = static_cast< int >(val2);
46544 {
46545 PyThreadState* __tstate = wxPyBeginAllowThreads();
46546 (arg1)->SetFlag(arg2);
46547 wxPyEndAllowThreads(__tstate);
46548 if (PyErr_Occurred()) SWIG_fail;
46549 }
46550 resultobj = SWIG_Py_Void();
46551 return resultobj;
46552 fail:
46553 return NULL;
46554 }
46555
46556
46557 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46558 PyObject *resultobj = 0;
46559 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46560 int result;
46561 void *argp1 = 0 ;
46562 int res1 = 0 ;
46563 PyObject *swig_obj[1] ;
46564
46565 if (!args) SWIG_fail;
46566 swig_obj[0] = args;
46567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46568 if (!SWIG_IsOK(res1)) {
46569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46570 }
46571 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46572 {
46573 PyThreadState* __tstate = wxPyBeginAllowThreads();
46574 result = (int)(arg1)->GetFlag();
46575 wxPyEndAllowThreads(__tstate);
46576 if (PyErr_Occurred()) SWIG_fail;
46577 }
46578 resultobj = SWIG_From_int(static_cast< int >(result));
46579 return resultobj;
46580 fail:
46581 return NULL;
46582 }
46583
46584
46585 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46586 PyObject *resultobj = 0;
46587 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46588 int arg2 ;
46589 void *argp1 = 0 ;
46590 int res1 = 0 ;
46591 int val2 ;
46592 int ecode2 = 0 ;
46593 PyObject * obj0 = 0 ;
46594 PyObject * obj1 = 0 ;
46595 char * kwnames[] = {
46596 (char *) "self",(char *) "border", NULL
46597 };
46598
46599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
46600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46601 if (!SWIG_IsOK(res1)) {
46602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46603 }
46604 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46605 ecode2 = SWIG_AsVal_int(obj1, &val2);
46606 if (!SWIG_IsOK(ecode2)) {
46607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
46608 }
46609 arg2 = static_cast< int >(val2);
46610 {
46611 PyThreadState* __tstate = wxPyBeginAllowThreads();
46612 (arg1)->SetBorder(arg2);
46613 wxPyEndAllowThreads(__tstate);
46614 if (PyErr_Occurred()) SWIG_fail;
46615 }
46616 resultobj = SWIG_Py_Void();
46617 return resultobj;
46618 fail:
46619 return NULL;
46620 }
46621
46622
46623 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46624 PyObject *resultobj = 0;
46625 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46626 int result;
46627 void *argp1 = 0 ;
46628 int res1 = 0 ;
46629 PyObject *swig_obj[1] ;
46630
46631 if (!args) SWIG_fail;
46632 swig_obj[0] = args;
46633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46634 if (!SWIG_IsOK(res1)) {
46635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46636 }
46637 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46638 {
46639 PyThreadState* __tstate = wxPyBeginAllowThreads();
46640 result = (int)(arg1)->GetBorder();
46641 wxPyEndAllowThreads(__tstate);
46642 if (PyErr_Occurred()) SWIG_fail;
46643 }
46644 resultobj = SWIG_From_int(static_cast< int >(result));
46645 return resultobj;
46646 fail:
46647 return NULL;
46648 }
46649
46650
46651 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46652 PyObject *resultobj = 0;
46653 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46654 wxWindow *result = 0 ;
46655 void *argp1 = 0 ;
46656 int res1 = 0 ;
46657 PyObject *swig_obj[1] ;
46658
46659 if (!args) SWIG_fail;
46660 swig_obj[0] = args;
46661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46662 if (!SWIG_IsOK(res1)) {
46663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46664 }
46665 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46666 {
46667 PyThreadState* __tstate = wxPyBeginAllowThreads();
46668 result = (wxWindow *)(arg1)->GetWindow();
46669 wxPyEndAllowThreads(__tstate);
46670 if (PyErr_Occurred()) SWIG_fail;
46671 }
46672 {
46673 resultobj = wxPyMake_wxObject(result, 0);
46674 }
46675 return resultobj;
46676 fail:
46677 return NULL;
46678 }
46679
46680
46681 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46682 PyObject *resultobj = 0;
46683 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46684 wxWindow *arg2 = (wxWindow *) 0 ;
46685 void *argp1 = 0 ;
46686 int res1 = 0 ;
46687 void *argp2 = 0 ;
46688 int res2 = 0 ;
46689 PyObject * obj0 = 0 ;
46690 PyObject * obj1 = 0 ;
46691 char * kwnames[] = {
46692 (char *) "self",(char *) "window", NULL
46693 };
46694
46695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46697 if (!SWIG_IsOK(res1)) {
46698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46699 }
46700 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46701 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46702 if (!SWIG_IsOK(res2)) {
46703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46704 }
46705 arg2 = reinterpret_cast< wxWindow * >(argp2);
46706 {
46707 PyThreadState* __tstate = wxPyBeginAllowThreads();
46708 (arg1)->SetWindow(arg2);
46709 wxPyEndAllowThreads(__tstate);
46710 if (PyErr_Occurred()) SWIG_fail;
46711 }
46712 resultobj = SWIG_Py_Void();
46713 return resultobj;
46714 fail:
46715 return NULL;
46716 }
46717
46718
46719 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46720 PyObject *resultobj = 0;
46721 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46722 wxSizer *result = 0 ;
46723 void *argp1 = 0 ;
46724 int res1 = 0 ;
46725 PyObject *swig_obj[1] ;
46726
46727 if (!args) SWIG_fail;
46728 swig_obj[0] = args;
46729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46730 if (!SWIG_IsOK(res1)) {
46731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46732 }
46733 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46734 {
46735 PyThreadState* __tstate = wxPyBeginAllowThreads();
46736 result = (wxSizer *)(arg1)->GetSizer();
46737 wxPyEndAllowThreads(__tstate);
46738 if (PyErr_Occurred()) SWIG_fail;
46739 }
46740 {
46741 resultobj = wxPyMake_wxObject(result, (bool)0);
46742 }
46743 return resultobj;
46744 fail:
46745 return NULL;
46746 }
46747
46748
46749 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46750 PyObject *resultobj = 0;
46751 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46752 wxSizer *arg2 = (wxSizer *) 0 ;
46753 void *argp1 = 0 ;
46754 int res1 = 0 ;
46755 int res2 = 0 ;
46756 PyObject * obj0 = 0 ;
46757 PyObject * obj1 = 0 ;
46758 char * kwnames[] = {
46759 (char *) "self",(char *) "sizer", NULL
46760 };
46761
46762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46764 if (!SWIG_IsOK(res1)) {
46765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46766 }
46767 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46768 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46769 if (!SWIG_IsOK(res2)) {
46770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46771 }
46772 {
46773 PyThreadState* __tstate = wxPyBeginAllowThreads();
46774 (arg1)->SetSizer(arg2);
46775 wxPyEndAllowThreads(__tstate);
46776 if (PyErr_Occurred()) SWIG_fail;
46777 }
46778 resultobj = SWIG_Py_Void();
46779 return resultobj;
46780 fail:
46781 return NULL;
46782 }
46783
46784
46785 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46786 PyObject *resultobj = 0;
46787 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46788 wxSize *result = 0 ;
46789 void *argp1 = 0 ;
46790 int res1 = 0 ;
46791 PyObject *swig_obj[1] ;
46792
46793 if (!args) SWIG_fail;
46794 swig_obj[0] = args;
46795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46796 if (!SWIG_IsOK(res1)) {
46797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46798 }
46799 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46800 {
46801 PyThreadState* __tstate = wxPyBeginAllowThreads();
46802 {
46803 wxSize const &_result_ref = (arg1)->GetSpacer();
46804 result = (wxSize *) &_result_ref;
46805 }
46806 wxPyEndAllowThreads(__tstate);
46807 if (PyErr_Occurred()) SWIG_fail;
46808 }
46809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46810 return resultobj;
46811 fail:
46812 return NULL;
46813 }
46814
46815
46816 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46817 PyObject *resultobj = 0;
46818 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46819 wxSize *arg2 = 0 ;
46820 void *argp1 = 0 ;
46821 int res1 = 0 ;
46822 wxSize temp2 ;
46823 PyObject * obj0 = 0 ;
46824 PyObject * obj1 = 0 ;
46825 char * kwnames[] = {
46826 (char *) "self",(char *) "size", NULL
46827 };
46828
46829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46831 if (!SWIG_IsOK(res1)) {
46832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46833 }
46834 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46835 {
46836 arg2 = &temp2;
46837 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46838 }
46839 {
46840 PyThreadState* __tstate = wxPyBeginAllowThreads();
46841 (arg1)->SetSpacer((wxSize const &)*arg2);
46842 wxPyEndAllowThreads(__tstate);
46843 if (PyErr_Occurred()) SWIG_fail;
46844 }
46845 resultobj = SWIG_Py_Void();
46846 return resultobj;
46847 fail:
46848 return NULL;
46849 }
46850
46851
46852 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46853 PyObject *resultobj = 0;
46854 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46855 bool arg2 ;
46856 void *argp1 = 0 ;
46857 int res1 = 0 ;
46858 bool val2 ;
46859 int ecode2 = 0 ;
46860 PyObject * obj0 = 0 ;
46861 PyObject * obj1 = 0 ;
46862 char * kwnames[] = {
46863 (char *) "self",(char *) "show", NULL
46864 };
46865
46866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46868 if (!SWIG_IsOK(res1)) {
46869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46870 }
46871 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46873 if (!SWIG_IsOK(ecode2)) {
46874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46875 }
46876 arg2 = static_cast< bool >(val2);
46877 {
46878 PyThreadState* __tstate = wxPyBeginAllowThreads();
46879 (arg1)->Show(arg2);
46880 wxPyEndAllowThreads(__tstate);
46881 if (PyErr_Occurred()) SWIG_fail;
46882 }
46883 resultobj = SWIG_Py_Void();
46884 return resultobj;
46885 fail:
46886 return NULL;
46887 }
46888
46889
46890 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46891 PyObject *resultobj = 0;
46892 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46893 bool result;
46894 void *argp1 = 0 ;
46895 int res1 = 0 ;
46896 PyObject *swig_obj[1] ;
46897
46898 if (!args) SWIG_fail;
46899 swig_obj[0] = args;
46900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46901 if (!SWIG_IsOK(res1)) {
46902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46903 }
46904 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46905 {
46906 PyThreadState* __tstate = wxPyBeginAllowThreads();
46907 result = (bool)(arg1)->IsShown();
46908 wxPyEndAllowThreads(__tstate);
46909 if (PyErr_Occurred()) SWIG_fail;
46910 }
46911 {
46912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46913 }
46914 return resultobj;
46915 fail:
46916 return NULL;
46917 }
46918
46919
46920 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46921 PyObject *resultobj = 0;
46922 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46923 wxPoint result;
46924 void *argp1 = 0 ;
46925 int res1 = 0 ;
46926 PyObject *swig_obj[1] ;
46927
46928 if (!args) SWIG_fail;
46929 swig_obj[0] = args;
46930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46931 if (!SWIG_IsOK(res1)) {
46932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46933 }
46934 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46935 {
46936 PyThreadState* __tstate = wxPyBeginAllowThreads();
46937 result = (arg1)->GetPosition();
46938 wxPyEndAllowThreads(__tstate);
46939 if (PyErr_Occurred()) SWIG_fail;
46940 }
46941 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46942 return resultobj;
46943 fail:
46944 return NULL;
46945 }
46946
46947
46948 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46949 PyObject *resultobj = 0;
46950 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46951 PyObject *result = 0 ;
46952 void *argp1 = 0 ;
46953 int res1 = 0 ;
46954 PyObject *swig_obj[1] ;
46955
46956 if (!args) SWIG_fail;
46957 swig_obj[0] = args;
46958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46959 if (!SWIG_IsOK(res1)) {
46960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46961 }
46962 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46963 {
46964 PyThreadState* __tstate = wxPyBeginAllowThreads();
46965 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46966 wxPyEndAllowThreads(__tstate);
46967 if (PyErr_Occurred()) SWIG_fail;
46968 }
46969 resultobj = result;
46970 return resultobj;
46971 fail:
46972 return NULL;
46973 }
46974
46975
46976 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46977 PyObject *resultobj = 0;
46978 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46979 PyObject *arg2 = (PyObject *) 0 ;
46980 void *argp1 = 0 ;
46981 int res1 = 0 ;
46982 PyObject * obj0 = 0 ;
46983 PyObject * obj1 = 0 ;
46984 char * kwnames[] = {
46985 (char *) "self",(char *) "userData", NULL
46986 };
46987
46988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46990 if (!SWIG_IsOK(res1)) {
46991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46992 }
46993 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46994 arg2 = obj1;
46995 {
46996 PyThreadState* __tstate = wxPyBeginAllowThreads();
46997 wxSizerItem_SetUserData(arg1,arg2);
46998 wxPyEndAllowThreads(__tstate);
46999 if (PyErr_Occurred()) SWIG_fail;
47000 }
47001 resultobj = SWIG_Py_Void();
47002 return resultobj;
47003 fail:
47004 return NULL;
47005 }
47006
47007
47008 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47009 PyObject *obj;
47010 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47011 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
47012 return SWIG_Py_Void();
47013 }
47014
47015 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47016 return SWIG_Python_InitShadowInstance(args);
47017 }
47018
47019 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47020 PyObject *resultobj = 0;
47021 wxSizer *arg1 = (wxSizer *) 0 ;
47022 void *argp1 = 0 ;
47023 int res1 = 0 ;
47024 PyObject *swig_obj[1] ;
47025
47026 if (!args) SWIG_fail;
47027 swig_obj[0] = args;
47028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
47029 if (!SWIG_IsOK(res1)) {
47030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47031 }
47032 arg1 = reinterpret_cast< wxSizer * >(argp1);
47033 {
47034 PyThreadState* __tstate = wxPyBeginAllowThreads();
47035 delete arg1;
47036
47037 wxPyEndAllowThreads(__tstate);
47038 if (PyErr_Occurred()) SWIG_fail;
47039 }
47040 resultobj = SWIG_Py_Void();
47041 return resultobj;
47042 fail:
47043 return NULL;
47044 }
47045
47046
47047 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47048 PyObject *resultobj = 0;
47049 wxSizer *arg1 = (wxSizer *) 0 ;
47050 PyObject *arg2 = (PyObject *) 0 ;
47051 void *argp1 = 0 ;
47052 int res1 = 0 ;
47053 PyObject * obj0 = 0 ;
47054 PyObject * obj1 = 0 ;
47055 char * kwnames[] = {
47056 (char *) "self",(char *) "_self", NULL
47057 };
47058
47059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
47060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47061 if (!SWIG_IsOK(res1)) {
47062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
47063 }
47064 arg1 = reinterpret_cast< wxSizer * >(argp1);
47065 arg2 = obj1;
47066 {
47067 PyThreadState* __tstate = wxPyBeginAllowThreads();
47068 wxSizer__setOORInfo(arg1,arg2);
47069 wxPyEndAllowThreads(__tstate);
47070 if (PyErr_Occurred()) SWIG_fail;
47071 }
47072 resultobj = SWIG_Py_Void();
47073 return resultobj;
47074 fail:
47075 return NULL;
47076 }
47077
47078
47079 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47080 PyObject *resultobj = 0;
47081 wxSizer *arg1 = (wxSizer *) 0 ;
47082 PyObject *arg2 = (PyObject *) 0 ;
47083 int arg3 = (int) 0 ;
47084 int arg4 = (int) 0 ;
47085 int arg5 = (int) 0 ;
47086 PyObject *arg6 = (PyObject *) NULL ;
47087 wxSizerItem *result = 0 ;
47088 void *argp1 = 0 ;
47089 int res1 = 0 ;
47090 int val3 ;
47091 int ecode3 = 0 ;
47092 int val4 ;
47093 int ecode4 = 0 ;
47094 int val5 ;
47095 int ecode5 = 0 ;
47096 PyObject * obj0 = 0 ;
47097 PyObject * obj1 = 0 ;
47098 PyObject * obj2 = 0 ;
47099 PyObject * obj3 = 0 ;
47100 PyObject * obj4 = 0 ;
47101 PyObject * obj5 = 0 ;
47102 char * kwnames[] = {
47103 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47104 };
47105
47106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47108 if (!SWIG_IsOK(res1)) {
47109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
47110 }
47111 arg1 = reinterpret_cast< wxSizer * >(argp1);
47112 arg2 = obj1;
47113 if (obj2) {
47114 ecode3 = SWIG_AsVal_int(obj2, &val3);
47115 if (!SWIG_IsOK(ecode3)) {
47116 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
47117 }
47118 arg3 = static_cast< int >(val3);
47119 }
47120 if (obj3) {
47121 ecode4 = SWIG_AsVal_int(obj3, &val4);
47122 if (!SWIG_IsOK(ecode4)) {
47123 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
47124 }
47125 arg4 = static_cast< int >(val4);
47126 }
47127 if (obj4) {
47128 ecode5 = SWIG_AsVal_int(obj4, &val5);
47129 if (!SWIG_IsOK(ecode5)) {
47130 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
47131 }
47132 arg5 = static_cast< int >(val5);
47133 }
47134 if (obj5) {
47135 arg6 = obj5;
47136 }
47137 {
47138 PyThreadState* __tstate = wxPyBeginAllowThreads();
47139 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
47140 wxPyEndAllowThreads(__tstate);
47141 if (PyErr_Occurred()) SWIG_fail;
47142 }
47143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47144 return resultobj;
47145 fail:
47146 return NULL;
47147 }
47148
47149
47150 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47151 PyObject *resultobj = 0;
47152 wxSizer *arg1 = (wxSizer *) 0 ;
47153 int arg2 ;
47154 PyObject *arg3 = (PyObject *) 0 ;
47155 int arg4 = (int) 0 ;
47156 int arg5 = (int) 0 ;
47157 int arg6 = (int) 0 ;
47158 PyObject *arg7 = (PyObject *) NULL ;
47159 wxSizerItem *result = 0 ;
47160 void *argp1 = 0 ;
47161 int res1 = 0 ;
47162 int val2 ;
47163 int ecode2 = 0 ;
47164 int val4 ;
47165 int ecode4 = 0 ;
47166 int val5 ;
47167 int ecode5 = 0 ;
47168 int val6 ;
47169 int ecode6 = 0 ;
47170 PyObject * obj0 = 0 ;
47171 PyObject * obj1 = 0 ;
47172 PyObject * obj2 = 0 ;
47173 PyObject * obj3 = 0 ;
47174 PyObject * obj4 = 0 ;
47175 PyObject * obj5 = 0 ;
47176 PyObject * obj6 = 0 ;
47177 char * kwnames[] = {
47178 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47179 };
47180
47181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47183 if (!SWIG_IsOK(res1)) {
47184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
47185 }
47186 arg1 = reinterpret_cast< wxSizer * >(argp1);
47187 ecode2 = SWIG_AsVal_int(obj1, &val2);
47188 if (!SWIG_IsOK(ecode2)) {
47189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
47190 }
47191 arg2 = static_cast< int >(val2);
47192 arg3 = obj2;
47193 if (obj3) {
47194 ecode4 = SWIG_AsVal_int(obj3, &val4);
47195 if (!SWIG_IsOK(ecode4)) {
47196 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
47197 }
47198 arg4 = static_cast< int >(val4);
47199 }
47200 if (obj4) {
47201 ecode5 = SWIG_AsVal_int(obj4, &val5);
47202 if (!SWIG_IsOK(ecode5)) {
47203 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
47204 }
47205 arg5 = static_cast< int >(val5);
47206 }
47207 if (obj5) {
47208 ecode6 = SWIG_AsVal_int(obj5, &val6);
47209 if (!SWIG_IsOK(ecode6)) {
47210 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
47211 }
47212 arg6 = static_cast< int >(val6);
47213 }
47214 if (obj6) {
47215 arg7 = obj6;
47216 }
47217 {
47218 PyThreadState* __tstate = wxPyBeginAllowThreads();
47219 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
47220 wxPyEndAllowThreads(__tstate);
47221 if (PyErr_Occurred()) SWIG_fail;
47222 }
47223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47224 return resultobj;
47225 fail:
47226 return NULL;
47227 }
47228
47229
47230 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47231 PyObject *resultobj = 0;
47232 wxSizer *arg1 = (wxSizer *) 0 ;
47233 PyObject *arg2 = (PyObject *) 0 ;
47234 int arg3 = (int) 0 ;
47235 int arg4 = (int) 0 ;
47236 int arg5 = (int) 0 ;
47237 PyObject *arg6 = (PyObject *) NULL ;
47238 wxSizerItem *result = 0 ;
47239 void *argp1 = 0 ;
47240 int res1 = 0 ;
47241 int val3 ;
47242 int ecode3 = 0 ;
47243 int val4 ;
47244 int ecode4 = 0 ;
47245 int val5 ;
47246 int ecode5 = 0 ;
47247 PyObject * obj0 = 0 ;
47248 PyObject * obj1 = 0 ;
47249 PyObject * obj2 = 0 ;
47250 PyObject * obj3 = 0 ;
47251 PyObject * obj4 = 0 ;
47252 PyObject * obj5 = 0 ;
47253 char * kwnames[] = {
47254 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
47255 };
47256
47257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
47258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47259 if (!SWIG_IsOK(res1)) {
47260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
47261 }
47262 arg1 = reinterpret_cast< wxSizer * >(argp1);
47263 arg2 = obj1;
47264 if (obj2) {
47265 ecode3 = SWIG_AsVal_int(obj2, &val3);
47266 if (!SWIG_IsOK(ecode3)) {
47267 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
47268 }
47269 arg3 = static_cast< int >(val3);
47270 }
47271 if (obj3) {
47272 ecode4 = SWIG_AsVal_int(obj3, &val4);
47273 if (!SWIG_IsOK(ecode4)) {
47274 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
47275 }
47276 arg4 = static_cast< int >(val4);
47277 }
47278 if (obj4) {
47279 ecode5 = SWIG_AsVal_int(obj4, &val5);
47280 if (!SWIG_IsOK(ecode5)) {
47281 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
47282 }
47283 arg5 = static_cast< int >(val5);
47284 }
47285 if (obj5) {
47286 arg6 = obj5;
47287 }
47288 {
47289 PyThreadState* __tstate = wxPyBeginAllowThreads();
47290 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
47291 wxPyEndAllowThreads(__tstate);
47292 if (PyErr_Occurred()) SWIG_fail;
47293 }
47294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47295 return resultobj;
47296 fail:
47297 return NULL;
47298 }
47299
47300
47301 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47302 PyObject *resultobj = 0;
47303 wxSizer *arg1 = (wxSizer *) 0 ;
47304 PyObject *arg2 = (PyObject *) 0 ;
47305 bool result;
47306 void *argp1 = 0 ;
47307 int res1 = 0 ;
47308 PyObject * obj0 = 0 ;
47309 PyObject * obj1 = 0 ;
47310 char * kwnames[] = {
47311 (char *) "self",(char *) "item", NULL
47312 };
47313
47314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
47315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47316 if (!SWIG_IsOK(res1)) {
47317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
47318 }
47319 arg1 = reinterpret_cast< wxSizer * >(argp1);
47320 arg2 = obj1;
47321 {
47322 PyThreadState* __tstate = wxPyBeginAllowThreads();
47323 result = (bool)wxSizer_Remove(arg1,arg2);
47324 wxPyEndAllowThreads(__tstate);
47325 if (PyErr_Occurred()) SWIG_fail;
47326 }
47327 {
47328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47329 }
47330 return resultobj;
47331 fail:
47332 return NULL;
47333 }
47334
47335
47336 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47337 PyObject *resultobj = 0;
47338 wxSizer *arg1 = (wxSizer *) 0 ;
47339 PyObject *arg2 = (PyObject *) 0 ;
47340 bool result;
47341 void *argp1 = 0 ;
47342 int res1 = 0 ;
47343 PyObject * obj0 = 0 ;
47344 PyObject * obj1 = 0 ;
47345 char * kwnames[] = {
47346 (char *) "self",(char *) "item", NULL
47347 };
47348
47349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
47350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47351 if (!SWIG_IsOK(res1)) {
47352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
47353 }
47354 arg1 = reinterpret_cast< wxSizer * >(argp1);
47355 arg2 = obj1;
47356 {
47357 PyThreadState* __tstate = wxPyBeginAllowThreads();
47358 result = (bool)wxSizer_Detach(arg1,arg2);
47359 wxPyEndAllowThreads(__tstate);
47360 if (PyErr_Occurred()) SWIG_fail;
47361 }
47362 {
47363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47364 }
47365 return resultobj;
47366 fail:
47367 return NULL;
47368 }
47369
47370
47371 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47372 PyObject *resultobj = 0;
47373 wxSizer *arg1 = (wxSizer *) 0 ;
47374 PyObject *arg2 = (PyObject *) 0 ;
47375 wxSizerItem *result = 0 ;
47376 void *argp1 = 0 ;
47377 int res1 = 0 ;
47378 PyObject * obj0 = 0 ;
47379 PyObject * obj1 = 0 ;
47380 char * kwnames[] = {
47381 (char *) "self",(char *) "item", NULL
47382 };
47383
47384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
47385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47386 if (!SWIG_IsOK(res1)) {
47387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47388 }
47389 arg1 = reinterpret_cast< wxSizer * >(argp1);
47390 arg2 = obj1;
47391 {
47392 PyThreadState* __tstate = wxPyBeginAllowThreads();
47393 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
47394 wxPyEndAllowThreads(__tstate);
47395 if (PyErr_Occurred()) SWIG_fail;
47396 }
47397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47398 return resultobj;
47399 fail:
47400 return NULL;
47401 }
47402
47403
47404 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47405 PyObject *resultobj = 0;
47406 wxSizer *arg1 = (wxSizer *) 0 ;
47407 PyObject *arg2 = (PyObject *) 0 ;
47408 wxSize *arg3 = 0 ;
47409 void *argp1 = 0 ;
47410 int res1 = 0 ;
47411 wxSize temp3 ;
47412 PyObject * obj0 = 0 ;
47413 PyObject * obj1 = 0 ;
47414 PyObject * obj2 = 0 ;
47415 char * kwnames[] = {
47416 (char *) "self",(char *) "item",(char *) "size", NULL
47417 };
47418
47419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47421 if (!SWIG_IsOK(res1)) {
47422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47423 }
47424 arg1 = reinterpret_cast< wxSizer * >(argp1);
47425 arg2 = obj1;
47426 {
47427 arg3 = &temp3;
47428 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
47429 }
47430 {
47431 PyThreadState* __tstate = wxPyBeginAllowThreads();
47432 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
47433 wxPyEndAllowThreads(__tstate);
47434 if (PyErr_Occurred()) SWIG_fail;
47435 }
47436 resultobj = SWIG_Py_Void();
47437 return resultobj;
47438 fail:
47439 return NULL;
47440 }
47441
47442
47443 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47444 PyObject *resultobj = 0;
47445 wxSizer *arg1 = (wxSizer *) 0 ;
47446 wxWindow *arg2 = (wxWindow *) 0 ;
47447 wxWindow *arg3 = (wxWindow *) 0 ;
47448 bool arg4 = (bool) false ;
47449 bool result;
47450 void *argp1 = 0 ;
47451 int res1 = 0 ;
47452 void *argp2 = 0 ;
47453 int res2 = 0 ;
47454 void *argp3 = 0 ;
47455 int res3 = 0 ;
47456 bool val4 ;
47457 int ecode4 = 0 ;
47458 PyObject * obj0 = 0 ;
47459 PyObject * obj1 = 0 ;
47460 PyObject * obj2 = 0 ;
47461 PyObject * obj3 = 0 ;
47462 char * kwnames[] = {
47463 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
47464 };
47465
47466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47468 if (!SWIG_IsOK(res1)) {
47469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
47470 }
47471 arg1 = reinterpret_cast< wxSizer * >(argp1);
47472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47473 if (!SWIG_IsOK(res2)) {
47474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
47475 }
47476 arg2 = reinterpret_cast< wxWindow * >(argp2);
47477 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
47478 if (!SWIG_IsOK(res3)) {
47479 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
47480 }
47481 arg3 = reinterpret_cast< wxWindow * >(argp3);
47482 if (obj3) {
47483 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47484 if (!SWIG_IsOK(ecode4)) {
47485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
47486 }
47487 arg4 = static_cast< bool >(val4);
47488 }
47489 {
47490 PyThreadState* __tstate = wxPyBeginAllowThreads();
47491 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47492 wxPyEndAllowThreads(__tstate);
47493 if (PyErr_Occurred()) SWIG_fail;
47494 }
47495 {
47496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47497 }
47498 return resultobj;
47499 fail:
47500 return NULL;
47501 }
47502
47503
47504 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47505 PyObject *resultobj = 0;
47506 wxSizer *arg1 = (wxSizer *) 0 ;
47507 wxSizer *arg2 = (wxSizer *) 0 ;
47508 wxSizer *arg3 = (wxSizer *) 0 ;
47509 bool arg4 = (bool) false ;
47510 bool result;
47511 void *argp1 = 0 ;
47512 int res1 = 0 ;
47513 void *argp2 = 0 ;
47514 int res2 = 0 ;
47515 void *argp3 = 0 ;
47516 int res3 = 0 ;
47517 bool val4 ;
47518 int ecode4 = 0 ;
47519 PyObject * obj0 = 0 ;
47520 PyObject * obj1 = 0 ;
47521 PyObject * obj2 = 0 ;
47522 PyObject * obj3 = 0 ;
47523 char * kwnames[] = {
47524 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
47525 };
47526
47527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47529 if (!SWIG_IsOK(res1)) {
47530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
47531 }
47532 arg1 = reinterpret_cast< wxSizer * >(argp1);
47533 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
47534 if (!SWIG_IsOK(res2)) {
47535 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
47536 }
47537 arg2 = reinterpret_cast< wxSizer * >(argp2);
47538 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
47539 if (!SWIG_IsOK(res3)) {
47540 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
47541 }
47542 arg3 = reinterpret_cast< wxSizer * >(argp3);
47543 if (obj3) {
47544 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47545 if (!SWIG_IsOK(ecode4)) {
47546 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
47547 }
47548 arg4 = static_cast< bool >(val4);
47549 }
47550 {
47551 PyThreadState* __tstate = wxPyBeginAllowThreads();
47552 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
47553 wxPyEndAllowThreads(__tstate);
47554 if (PyErr_Occurred()) SWIG_fail;
47555 }
47556 {
47557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47558 }
47559 return resultobj;
47560 fail:
47561 return NULL;
47562 }
47563
47564
47565 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47566 PyObject *resultobj = 0;
47567 wxSizer *arg1 = (wxSizer *) 0 ;
47568 size_t arg2 ;
47569 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47570 bool result;
47571 void *argp1 = 0 ;
47572 int res1 = 0 ;
47573 size_t val2 ;
47574 int ecode2 = 0 ;
47575 void *argp3 = 0 ;
47576 int res3 = 0 ;
47577 PyObject * obj0 = 0 ;
47578 PyObject * obj1 = 0 ;
47579 PyObject * obj2 = 0 ;
47580 char * kwnames[] = {
47581 (char *) "self",(char *) "index",(char *) "newitem", NULL
47582 };
47583
47584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47586 if (!SWIG_IsOK(res1)) {
47587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47588 }
47589 arg1 = reinterpret_cast< wxSizer * >(argp1);
47590 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47591 if (!SWIG_IsOK(ecode2)) {
47592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
47593 }
47594 arg2 = static_cast< size_t >(val2);
47595 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
47596 if (!SWIG_IsOK(res3)) {
47597 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47598 }
47599 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
47600 {
47601 PyThreadState* __tstate = wxPyBeginAllowThreads();
47602 result = (bool)(arg1)->Replace(arg2,arg3);
47603 wxPyEndAllowThreads(__tstate);
47604 if (PyErr_Occurred()) SWIG_fail;
47605 }
47606 {
47607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47608 }
47609 return resultobj;
47610 fail:
47611 return NULL;
47612 }
47613
47614
47615 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47616 PyObject *resultobj = 0;
47617 wxSizer *arg1 = (wxSizer *) 0 ;
47618 wxWindow *arg2 = (wxWindow *) 0 ;
47619 void *argp1 = 0 ;
47620 int res1 = 0 ;
47621 void *argp2 = 0 ;
47622 int res2 = 0 ;
47623 PyObject * obj0 = 0 ;
47624 PyObject * obj1 = 0 ;
47625 char * kwnames[] = {
47626 (char *) "self",(char *) "window", NULL
47627 };
47628
47629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
47630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47631 if (!SWIG_IsOK(res1)) {
47632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
47633 }
47634 arg1 = reinterpret_cast< wxSizer * >(argp1);
47635 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47636 if (!SWIG_IsOK(res2)) {
47637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
47638 }
47639 arg2 = reinterpret_cast< wxWindow * >(argp2);
47640 {
47641 PyThreadState* __tstate = wxPyBeginAllowThreads();
47642 (arg1)->SetContainingWindow(arg2);
47643 wxPyEndAllowThreads(__tstate);
47644 if (PyErr_Occurred()) SWIG_fail;
47645 }
47646 resultobj = SWIG_Py_Void();
47647 return resultobj;
47648 fail:
47649 return NULL;
47650 }
47651
47652
47653 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47654 PyObject *resultobj = 0;
47655 wxSizer *arg1 = (wxSizer *) 0 ;
47656 wxWindow *result = 0 ;
47657 void *argp1 = 0 ;
47658 int res1 = 0 ;
47659 PyObject *swig_obj[1] ;
47660
47661 if (!args) SWIG_fail;
47662 swig_obj[0] = args;
47663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47664 if (!SWIG_IsOK(res1)) {
47665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
47666 }
47667 arg1 = reinterpret_cast< wxSizer * >(argp1);
47668 {
47669 PyThreadState* __tstate = wxPyBeginAllowThreads();
47670 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
47671 wxPyEndAllowThreads(__tstate);
47672 if (PyErr_Occurred()) SWIG_fail;
47673 }
47674 {
47675 resultobj = wxPyMake_wxObject(result, 0);
47676 }
47677 return resultobj;
47678 fail:
47679 return NULL;
47680 }
47681
47682
47683 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47684 PyObject *resultobj = 0;
47685 wxSizer *arg1 = (wxSizer *) 0 ;
47686 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47687 wxSizerItem *result = 0 ;
47688 void *argp1 = 0 ;
47689 int res1 = 0 ;
47690 int res2 = 0 ;
47691 PyObject * obj0 = 0 ;
47692 PyObject * obj1 = 0 ;
47693 char * kwnames[] = {
47694 (char *) "self",(char *) "item", NULL
47695 };
47696
47697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
47698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47699 if (!SWIG_IsOK(res1)) {
47700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47701 }
47702 arg1 = reinterpret_cast< wxSizer * >(argp1);
47703 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47704 if (!SWIG_IsOK(res2)) {
47705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47706 }
47707 {
47708 PyThreadState* __tstate = wxPyBeginAllowThreads();
47709 result = (wxSizerItem *)(arg1)->Add(arg2);
47710 wxPyEndAllowThreads(__tstate);
47711 if (PyErr_Occurred()) SWIG_fail;
47712 }
47713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47714 return resultobj;
47715 fail:
47716 return NULL;
47717 }
47718
47719
47720 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47721 PyObject *resultobj = 0;
47722 wxSizer *arg1 = (wxSizer *) 0 ;
47723 size_t arg2 ;
47724 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
47725 wxSizerItem *result = 0 ;
47726 void *argp1 = 0 ;
47727 int res1 = 0 ;
47728 size_t val2 ;
47729 int ecode2 = 0 ;
47730 int res3 = 0 ;
47731 PyObject * obj0 = 0 ;
47732 PyObject * obj1 = 0 ;
47733 PyObject * obj2 = 0 ;
47734 char * kwnames[] = {
47735 (char *) "self",(char *) "index",(char *) "item", NULL
47736 };
47737
47738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47740 if (!SWIG_IsOK(res1)) {
47741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47742 }
47743 arg1 = reinterpret_cast< wxSizer * >(argp1);
47744 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47745 if (!SWIG_IsOK(ecode2)) {
47746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
47747 }
47748 arg2 = static_cast< size_t >(val2);
47749 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47750 if (!SWIG_IsOK(res3)) {
47751 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
47752 }
47753 {
47754 PyThreadState* __tstate = wxPyBeginAllowThreads();
47755 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
47756 wxPyEndAllowThreads(__tstate);
47757 if (PyErr_Occurred()) SWIG_fail;
47758 }
47759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47760 return resultobj;
47761 fail:
47762 return NULL;
47763 }
47764
47765
47766 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47767 PyObject *resultobj = 0;
47768 wxSizer *arg1 = (wxSizer *) 0 ;
47769 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
47770 wxSizerItem *result = 0 ;
47771 void *argp1 = 0 ;
47772 int res1 = 0 ;
47773 int res2 = 0 ;
47774 PyObject * obj0 = 0 ;
47775 PyObject * obj1 = 0 ;
47776 char * kwnames[] = {
47777 (char *) "self",(char *) "item", NULL
47778 };
47779
47780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
47781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47782 if (!SWIG_IsOK(res1)) {
47783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
47784 }
47785 arg1 = reinterpret_cast< wxSizer * >(argp1);
47786 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
47787 if (!SWIG_IsOK(res2)) {
47788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
47789 }
47790 {
47791 PyThreadState* __tstate = wxPyBeginAllowThreads();
47792 result = (wxSizerItem *)(arg1)->Prepend(arg2);
47793 wxPyEndAllowThreads(__tstate);
47794 if (PyErr_Occurred()) SWIG_fail;
47795 }
47796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
47797 return resultobj;
47798 fail:
47799 return NULL;
47800 }
47801
47802
47803 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47804 PyObject *resultobj = 0;
47805 wxSizer *arg1 = (wxSizer *) 0 ;
47806 int arg2 ;
47807 int arg3 ;
47808 int arg4 ;
47809 int arg5 ;
47810 void *argp1 = 0 ;
47811 int res1 = 0 ;
47812 int val2 ;
47813 int ecode2 = 0 ;
47814 int val3 ;
47815 int ecode3 = 0 ;
47816 int val4 ;
47817 int ecode4 = 0 ;
47818 int val5 ;
47819 int ecode5 = 0 ;
47820 PyObject * obj0 = 0 ;
47821 PyObject * obj1 = 0 ;
47822 PyObject * obj2 = 0 ;
47823 PyObject * obj3 = 0 ;
47824 PyObject * obj4 = 0 ;
47825 char * kwnames[] = {
47826 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
47827 };
47828
47829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
47830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47831 if (!SWIG_IsOK(res1)) {
47832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
47833 }
47834 arg1 = reinterpret_cast< wxSizer * >(argp1);
47835 ecode2 = SWIG_AsVal_int(obj1, &val2);
47836 if (!SWIG_IsOK(ecode2)) {
47837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
47838 }
47839 arg2 = static_cast< int >(val2);
47840 ecode3 = SWIG_AsVal_int(obj2, &val3);
47841 if (!SWIG_IsOK(ecode3)) {
47842 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
47843 }
47844 arg3 = static_cast< int >(val3);
47845 ecode4 = SWIG_AsVal_int(obj3, &val4);
47846 if (!SWIG_IsOK(ecode4)) {
47847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
47848 }
47849 arg4 = static_cast< int >(val4);
47850 ecode5 = SWIG_AsVal_int(obj4, &val5);
47851 if (!SWIG_IsOK(ecode5)) {
47852 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
47853 }
47854 arg5 = static_cast< int >(val5);
47855 {
47856 PyThreadState* __tstate = wxPyBeginAllowThreads();
47857 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
47858 wxPyEndAllowThreads(__tstate);
47859 if (PyErr_Occurred()) SWIG_fail;
47860 }
47861 resultobj = SWIG_Py_Void();
47862 return resultobj;
47863 fail:
47864 return NULL;
47865 }
47866
47867
47868 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47869 PyObject *resultobj = 0;
47870 wxSizer *arg1 = (wxSizer *) 0 ;
47871 wxSize *arg2 = 0 ;
47872 void *argp1 = 0 ;
47873 int res1 = 0 ;
47874 wxSize temp2 ;
47875 PyObject * obj0 = 0 ;
47876 PyObject * obj1 = 0 ;
47877 char * kwnames[] = {
47878 (char *) "self",(char *) "size", NULL
47879 };
47880
47881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
47882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47883 if (!SWIG_IsOK(res1)) {
47884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47885 }
47886 arg1 = reinterpret_cast< wxSizer * >(argp1);
47887 {
47888 arg2 = &temp2;
47889 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
47890 }
47891 {
47892 PyThreadState* __tstate = wxPyBeginAllowThreads();
47893 (arg1)->SetMinSize((wxSize const &)*arg2);
47894 wxPyEndAllowThreads(__tstate);
47895 if (PyErr_Occurred()) SWIG_fail;
47896 }
47897 resultobj = SWIG_Py_Void();
47898 return resultobj;
47899 fail:
47900 return NULL;
47901 }
47902
47903
47904 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47905 PyObject *resultobj = 0;
47906 wxSizer *arg1 = (wxSizer *) 0 ;
47907 wxSize result;
47908 void *argp1 = 0 ;
47909 int res1 = 0 ;
47910 PyObject *swig_obj[1] ;
47911
47912 if (!args) SWIG_fail;
47913 swig_obj[0] = args;
47914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47915 if (!SWIG_IsOK(res1)) {
47916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47917 }
47918 arg1 = reinterpret_cast< wxSizer * >(argp1);
47919 {
47920 PyThreadState* __tstate = wxPyBeginAllowThreads();
47921 result = (arg1)->GetSize();
47922 wxPyEndAllowThreads(__tstate);
47923 if (PyErr_Occurred()) SWIG_fail;
47924 }
47925 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47926 return resultobj;
47927 fail:
47928 return NULL;
47929 }
47930
47931
47932 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47933 PyObject *resultobj = 0;
47934 wxSizer *arg1 = (wxSizer *) 0 ;
47935 wxPoint result;
47936 void *argp1 = 0 ;
47937 int res1 = 0 ;
47938 PyObject *swig_obj[1] ;
47939
47940 if (!args) SWIG_fail;
47941 swig_obj[0] = args;
47942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47943 if (!SWIG_IsOK(res1)) {
47944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47945 }
47946 arg1 = reinterpret_cast< wxSizer * >(argp1);
47947 {
47948 PyThreadState* __tstate = wxPyBeginAllowThreads();
47949 result = (arg1)->GetPosition();
47950 wxPyEndAllowThreads(__tstate);
47951 if (PyErr_Occurred()) SWIG_fail;
47952 }
47953 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47954 return resultobj;
47955 fail:
47956 return NULL;
47957 }
47958
47959
47960 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47961 PyObject *resultobj = 0;
47962 wxSizer *arg1 = (wxSizer *) 0 ;
47963 wxSize result;
47964 void *argp1 = 0 ;
47965 int res1 = 0 ;
47966 PyObject *swig_obj[1] ;
47967
47968 if (!args) SWIG_fail;
47969 swig_obj[0] = args;
47970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47971 if (!SWIG_IsOK(res1)) {
47972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47973 }
47974 arg1 = reinterpret_cast< wxSizer * >(argp1);
47975 {
47976 PyThreadState* __tstate = wxPyBeginAllowThreads();
47977 result = (arg1)->GetMinSize();
47978 wxPyEndAllowThreads(__tstate);
47979 if (PyErr_Occurred()) SWIG_fail;
47980 }
47981 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47982 return resultobj;
47983 fail:
47984 return NULL;
47985 }
47986
47987
47988 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47989 PyObject *resultobj = 0;
47990 wxSizer *arg1 = (wxSizer *) 0 ;
47991 void *argp1 = 0 ;
47992 int res1 = 0 ;
47993 PyObject *swig_obj[1] ;
47994
47995 if (!args) SWIG_fail;
47996 swig_obj[0] = args;
47997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47998 if (!SWIG_IsOK(res1)) {
47999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
48000 }
48001 arg1 = reinterpret_cast< wxSizer * >(argp1);
48002 {
48003 PyThreadState* __tstate = wxPyBeginAllowThreads();
48004 (arg1)->RecalcSizes();
48005 wxPyEndAllowThreads(__tstate);
48006 if (PyErr_Occurred()) SWIG_fail;
48007 }
48008 resultobj = SWIG_Py_Void();
48009 return resultobj;
48010 fail:
48011 return NULL;
48012 }
48013
48014
48015 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48016 PyObject *resultobj = 0;
48017 wxSizer *arg1 = (wxSizer *) 0 ;
48018 wxSize result;
48019 void *argp1 = 0 ;
48020 int res1 = 0 ;
48021 PyObject *swig_obj[1] ;
48022
48023 if (!args) SWIG_fail;
48024 swig_obj[0] = args;
48025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48026 if (!SWIG_IsOK(res1)) {
48027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
48028 }
48029 arg1 = reinterpret_cast< wxSizer * >(argp1);
48030 {
48031 PyThreadState* __tstate = wxPyBeginAllowThreads();
48032 result = (arg1)->CalcMin();
48033 wxPyEndAllowThreads(__tstate);
48034 if (PyErr_Occurred()) SWIG_fail;
48035 }
48036 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48037 return resultobj;
48038 fail:
48039 return NULL;
48040 }
48041
48042
48043 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48044 PyObject *resultobj = 0;
48045 wxSizer *arg1 = (wxSizer *) 0 ;
48046 void *argp1 = 0 ;
48047 int res1 = 0 ;
48048 PyObject *swig_obj[1] ;
48049
48050 if (!args) SWIG_fail;
48051 swig_obj[0] = args;
48052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48053 if (!SWIG_IsOK(res1)) {
48054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
48055 }
48056 arg1 = reinterpret_cast< wxSizer * >(argp1);
48057 {
48058 PyThreadState* __tstate = wxPyBeginAllowThreads();
48059 (arg1)->Layout();
48060 wxPyEndAllowThreads(__tstate);
48061 if (PyErr_Occurred()) SWIG_fail;
48062 }
48063 resultobj = SWIG_Py_Void();
48064 return resultobj;
48065 fail:
48066 return NULL;
48067 }
48068
48069
48070 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48071 PyObject *resultobj = 0;
48072 wxSizer *arg1 = (wxSizer *) 0 ;
48073 wxWindow *arg2 = (wxWindow *) 0 ;
48074 wxSize result;
48075 void *argp1 = 0 ;
48076 int res1 = 0 ;
48077 void *argp2 = 0 ;
48078 int res2 = 0 ;
48079 PyObject * obj0 = 0 ;
48080 PyObject * obj1 = 0 ;
48081 char * kwnames[] = {
48082 (char *) "self",(char *) "window", NULL
48083 };
48084
48085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
48086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48087 if (!SWIG_IsOK(res1)) {
48088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
48089 }
48090 arg1 = reinterpret_cast< wxSizer * >(argp1);
48091 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48092 if (!SWIG_IsOK(res2)) {
48093 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
48094 }
48095 arg2 = reinterpret_cast< wxWindow * >(argp2);
48096 {
48097 PyThreadState* __tstate = wxPyBeginAllowThreads();
48098 result = (arg1)->Fit(arg2);
48099 wxPyEndAllowThreads(__tstate);
48100 if (PyErr_Occurred()) SWIG_fail;
48101 }
48102 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48103 return resultobj;
48104 fail:
48105 return NULL;
48106 }
48107
48108
48109 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48110 PyObject *resultobj = 0;
48111 wxSizer *arg1 = (wxSizer *) 0 ;
48112 wxWindow *arg2 = (wxWindow *) 0 ;
48113 void *argp1 = 0 ;
48114 int res1 = 0 ;
48115 void *argp2 = 0 ;
48116 int res2 = 0 ;
48117 PyObject * obj0 = 0 ;
48118 PyObject * obj1 = 0 ;
48119 char * kwnames[] = {
48120 (char *) "self",(char *) "window", NULL
48121 };
48122
48123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
48124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48125 if (!SWIG_IsOK(res1)) {
48126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
48127 }
48128 arg1 = reinterpret_cast< wxSizer * >(argp1);
48129 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48130 if (!SWIG_IsOK(res2)) {
48131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
48132 }
48133 arg2 = reinterpret_cast< wxWindow * >(argp2);
48134 {
48135 PyThreadState* __tstate = wxPyBeginAllowThreads();
48136 (arg1)->FitInside(arg2);
48137 wxPyEndAllowThreads(__tstate);
48138 if (PyErr_Occurred()) SWIG_fail;
48139 }
48140 resultobj = SWIG_Py_Void();
48141 return resultobj;
48142 fail:
48143 return NULL;
48144 }
48145
48146
48147 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48148 PyObject *resultobj = 0;
48149 wxSizer *arg1 = (wxSizer *) 0 ;
48150 wxWindow *arg2 = (wxWindow *) 0 ;
48151 void *argp1 = 0 ;
48152 int res1 = 0 ;
48153 void *argp2 = 0 ;
48154 int res2 = 0 ;
48155 PyObject * obj0 = 0 ;
48156 PyObject * obj1 = 0 ;
48157 char * kwnames[] = {
48158 (char *) "self",(char *) "window", NULL
48159 };
48160
48161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48163 if (!SWIG_IsOK(res1)) {
48164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48165 }
48166 arg1 = reinterpret_cast< wxSizer * >(argp1);
48167 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48168 if (!SWIG_IsOK(res2)) {
48169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48170 }
48171 arg2 = reinterpret_cast< wxWindow * >(argp2);
48172 {
48173 PyThreadState* __tstate = wxPyBeginAllowThreads();
48174 (arg1)->SetSizeHints(arg2);
48175 wxPyEndAllowThreads(__tstate);
48176 if (PyErr_Occurred()) SWIG_fail;
48177 }
48178 resultobj = SWIG_Py_Void();
48179 return resultobj;
48180 fail:
48181 return NULL;
48182 }
48183
48184
48185 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48186 PyObject *resultobj = 0;
48187 wxSizer *arg1 = (wxSizer *) 0 ;
48188 wxWindow *arg2 = (wxWindow *) 0 ;
48189 void *argp1 = 0 ;
48190 int res1 = 0 ;
48191 void *argp2 = 0 ;
48192 int res2 = 0 ;
48193 PyObject * obj0 = 0 ;
48194 PyObject * obj1 = 0 ;
48195 char * kwnames[] = {
48196 (char *) "self",(char *) "window", NULL
48197 };
48198
48199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
48200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48201 if (!SWIG_IsOK(res1)) {
48202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
48203 }
48204 arg1 = reinterpret_cast< wxSizer * >(argp1);
48205 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48206 if (!SWIG_IsOK(res2)) {
48207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
48208 }
48209 arg2 = reinterpret_cast< wxWindow * >(argp2);
48210 {
48211 PyThreadState* __tstate = wxPyBeginAllowThreads();
48212 (arg1)->SetVirtualSizeHints(arg2);
48213 wxPyEndAllowThreads(__tstate);
48214 if (PyErr_Occurred()) SWIG_fail;
48215 }
48216 resultobj = SWIG_Py_Void();
48217 return resultobj;
48218 fail:
48219 return NULL;
48220 }
48221
48222
48223 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48224 PyObject *resultobj = 0;
48225 wxSizer *arg1 = (wxSizer *) 0 ;
48226 bool arg2 = (bool) false ;
48227 void *argp1 = 0 ;
48228 int res1 = 0 ;
48229 bool val2 ;
48230 int ecode2 = 0 ;
48231 PyObject * obj0 = 0 ;
48232 PyObject * obj1 = 0 ;
48233 char * kwnames[] = {
48234 (char *) "self",(char *) "deleteWindows", NULL
48235 };
48236
48237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
48238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48239 if (!SWIG_IsOK(res1)) {
48240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
48241 }
48242 arg1 = reinterpret_cast< wxSizer * >(argp1);
48243 if (obj1) {
48244 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48245 if (!SWIG_IsOK(ecode2)) {
48246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
48247 }
48248 arg2 = static_cast< bool >(val2);
48249 }
48250 {
48251 PyThreadState* __tstate = wxPyBeginAllowThreads();
48252 (arg1)->Clear(arg2);
48253 wxPyEndAllowThreads(__tstate);
48254 if (PyErr_Occurred()) SWIG_fail;
48255 }
48256 resultobj = SWIG_Py_Void();
48257 return resultobj;
48258 fail:
48259 return NULL;
48260 }
48261
48262
48263 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48264 PyObject *resultobj = 0;
48265 wxSizer *arg1 = (wxSizer *) 0 ;
48266 void *argp1 = 0 ;
48267 int res1 = 0 ;
48268 PyObject *swig_obj[1] ;
48269
48270 if (!args) SWIG_fail;
48271 swig_obj[0] = args;
48272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48273 if (!SWIG_IsOK(res1)) {
48274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
48275 }
48276 arg1 = reinterpret_cast< wxSizer * >(argp1);
48277 {
48278 PyThreadState* __tstate = wxPyBeginAllowThreads();
48279 (arg1)->DeleteWindows();
48280 wxPyEndAllowThreads(__tstate);
48281 if (PyErr_Occurred()) SWIG_fail;
48282 }
48283 resultobj = SWIG_Py_Void();
48284 return resultobj;
48285 fail:
48286 return NULL;
48287 }
48288
48289
48290 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48291 PyObject *resultobj = 0;
48292 wxSizer *arg1 = (wxSizer *) 0 ;
48293 PyObject *result = 0 ;
48294 void *argp1 = 0 ;
48295 int res1 = 0 ;
48296 PyObject *swig_obj[1] ;
48297
48298 if (!args) SWIG_fail;
48299 swig_obj[0] = args;
48300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48301 if (!SWIG_IsOK(res1)) {
48302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
48303 }
48304 arg1 = reinterpret_cast< wxSizer * >(argp1);
48305 {
48306 PyThreadState* __tstate = wxPyBeginAllowThreads();
48307 result = (PyObject *)wxSizer_GetChildren(arg1);
48308 wxPyEndAllowThreads(__tstate);
48309 if (PyErr_Occurred()) SWIG_fail;
48310 }
48311 resultobj = result;
48312 return resultobj;
48313 fail:
48314 return NULL;
48315 }
48316
48317
48318 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48319 PyObject *resultobj = 0;
48320 wxSizer *arg1 = (wxSizer *) 0 ;
48321 PyObject *arg2 = (PyObject *) 0 ;
48322 bool arg3 = (bool) true ;
48323 bool arg4 = (bool) false ;
48324 bool result;
48325 void *argp1 = 0 ;
48326 int res1 = 0 ;
48327 bool val3 ;
48328 int ecode3 = 0 ;
48329 bool val4 ;
48330 int ecode4 = 0 ;
48331 PyObject * obj0 = 0 ;
48332 PyObject * obj1 = 0 ;
48333 PyObject * obj2 = 0 ;
48334 PyObject * obj3 = 0 ;
48335 char * kwnames[] = {
48336 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
48337 };
48338
48339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48341 if (!SWIG_IsOK(res1)) {
48342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
48343 }
48344 arg1 = reinterpret_cast< wxSizer * >(argp1);
48345 arg2 = obj1;
48346 if (obj2) {
48347 ecode3 = SWIG_AsVal_bool(obj2, &val3);
48348 if (!SWIG_IsOK(ecode3)) {
48349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
48350 }
48351 arg3 = static_cast< bool >(val3);
48352 }
48353 if (obj3) {
48354 ecode4 = SWIG_AsVal_bool(obj3, &val4);
48355 if (!SWIG_IsOK(ecode4)) {
48356 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
48357 }
48358 arg4 = static_cast< bool >(val4);
48359 }
48360 {
48361 PyThreadState* __tstate = wxPyBeginAllowThreads();
48362 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
48363 wxPyEndAllowThreads(__tstate);
48364 if (PyErr_Occurred()) SWIG_fail;
48365 }
48366 {
48367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48368 }
48369 return resultobj;
48370 fail:
48371 return NULL;
48372 }
48373
48374
48375 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48376 PyObject *resultobj = 0;
48377 wxSizer *arg1 = (wxSizer *) 0 ;
48378 PyObject *arg2 = (PyObject *) 0 ;
48379 bool result;
48380 void *argp1 = 0 ;
48381 int res1 = 0 ;
48382 PyObject * obj0 = 0 ;
48383 PyObject * obj1 = 0 ;
48384 char * kwnames[] = {
48385 (char *) "self",(char *) "item", NULL
48386 };
48387
48388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
48389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48390 if (!SWIG_IsOK(res1)) {
48391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
48392 }
48393 arg1 = reinterpret_cast< wxSizer * >(argp1);
48394 arg2 = obj1;
48395 {
48396 PyThreadState* __tstate = wxPyBeginAllowThreads();
48397 result = (bool)wxSizer_IsShown(arg1,arg2);
48398 wxPyEndAllowThreads(__tstate);
48399 if (PyErr_Occurred()) SWIG_fail;
48400 }
48401 {
48402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48403 }
48404 return resultobj;
48405 fail:
48406 return NULL;
48407 }
48408
48409
48410 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48411 PyObject *resultobj = 0;
48412 wxSizer *arg1 = (wxSizer *) 0 ;
48413 bool arg2 ;
48414 void *argp1 = 0 ;
48415 int res1 = 0 ;
48416 bool val2 ;
48417 int ecode2 = 0 ;
48418 PyObject * obj0 = 0 ;
48419 PyObject * obj1 = 0 ;
48420 char * kwnames[] = {
48421 (char *) "self",(char *) "show", NULL
48422 };
48423
48424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
48425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
48426 if (!SWIG_IsOK(res1)) {
48427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
48428 }
48429 arg1 = reinterpret_cast< wxSizer * >(argp1);
48430 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48431 if (!SWIG_IsOK(ecode2)) {
48432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
48433 }
48434 arg2 = static_cast< bool >(val2);
48435 {
48436 PyThreadState* __tstate = wxPyBeginAllowThreads();
48437 (arg1)->ShowItems(arg2);
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 *Sizer_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_wxSizer, SWIG_NewClientData(obj));
48452 return SWIG_Py_Void();
48453 }
48454
48455 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48456 PyObject *resultobj = 0;
48457 wxPySizer *result = 0 ;
48458
48459 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
48460 {
48461 PyThreadState* __tstate = wxPyBeginAllowThreads();
48462 result = (wxPySizer *)new wxPySizer();
48463 wxPyEndAllowThreads(__tstate);
48464 if (PyErr_Occurred()) SWIG_fail;
48465 }
48466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
48467 return resultobj;
48468 fail:
48469 return NULL;
48470 }
48471
48472
48473 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48474 PyObject *resultobj = 0;
48475 wxPySizer *arg1 = (wxPySizer *) 0 ;
48476 PyObject *arg2 = (PyObject *) 0 ;
48477 PyObject *arg3 = (PyObject *) 0 ;
48478 void *argp1 = 0 ;
48479 int res1 = 0 ;
48480 PyObject * obj0 = 0 ;
48481 PyObject * obj1 = 0 ;
48482 PyObject * obj2 = 0 ;
48483 char * kwnames[] = {
48484 (char *) "self",(char *) "self",(char *) "_class", NULL
48485 };
48486
48487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
48489 if (!SWIG_IsOK(res1)) {
48490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
48491 }
48492 arg1 = reinterpret_cast< wxPySizer * >(argp1);
48493 arg2 = obj1;
48494 arg3 = obj2;
48495 {
48496 PyThreadState* __tstate = wxPyBeginAllowThreads();
48497 (arg1)->_setCallbackInfo(arg2,arg3);
48498 wxPyEndAllowThreads(__tstate);
48499 if (PyErr_Occurred()) SWIG_fail;
48500 }
48501 resultobj = SWIG_Py_Void();
48502 return resultobj;
48503 fail:
48504 return NULL;
48505 }
48506
48507
48508 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48509 PyObject *obj;
48510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48511 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
48512 return SWIG_Py_Void();
48513 }
48514
48515 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48516 return SWIG_Python_InitShadowInstance(args);
48517 }
48518
48519 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48520 PyObject *resultobj = 0;
48521 int arg1 = (int) wxHORIZONTAL ;
48522 wxBoxSizer *result = 0 ;
48523 int val1 ;
48524 int ecode1 = 0 ;
48525 PyObject * obj0 = 0 ;
48526 char * kwnames[] = {
48527 (char *) "orient", NULL
48528 };
48529
48530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
48531 if (obj0) {
48532 ecode1 = SWIG_AsVal_int(obj0, &val1);
48533 if (!SWIG_IsOK(ecode1)) {
48534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
48535 }
48536 arg1 = static_cast< int >(val1);
48537 }
48538 {
48539 PyThreadState* __tstate = wxPyBeginAllowThreads();
48540 result = (wxBoxSizer *)new wxBoxSizer(arg1);
48541 wxPyEndAllowThreads(__tstate);
48542 if (PyErr_Occurred()) SWIG_fail;
48543 }
48544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
48545 return resultobj;
48546 fail:
48547 return NULL;
48548 }
48549
48550
48551 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48552 PyObject *resultobj = 0;
48553 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48554 int result;
48555 void *argp1 = 0 ;
48556 int res1 = 0 ;
48557 PyObject *swig_obj[1] ;
48558
48559 if (!args) SWIG_fail;
48560 swig_obj[0] = args;
48561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48562 if (!SWIG_IsOK(res1)) {
48563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48564 }
48565 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48566 {
48567 PyThreadState* __tstate = wxPyBeginAllowThreads();
48568 result = (int)(arg1)->GetOrientation();
48569 wxPyEndAllowThreads(__tstate);
48570 if (PyErr_Occurred()) SWIG_fail;
48571 }
48572 resultobj = SWIG_From_int(static_cast< int >(result));
48573 return resultobj;
48574 fail:
48575 return NULL;
48576 }
48577
48578
48579 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48580 PyObject *resultobj = 0;
48581 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
48582 int arg2 ;
48583 void *argp1 = 0 ;
48584 int res1 = 0 ;
48585 int val2 ;
48586 int ecode2 = 0 ;
48587 PyObject * obj0 = 0 ;
48588 PyObject * obj1 = 0 ;
48589 char * kwnames[] = {
48590 (char *) "self",(char *) "orient", NULL
48591 };
48592
48593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
48594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
48595 if (!SWIG_IsOK(res1)) {
48596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
48597 }
48598 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
48599 ecode2 = SWIG_AsVal_int(obj1, &val2);
48600 if (!SWIG_IsOK(ecode2)) {
48601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
48602 }
48603 arg2 = static_cast< int >(val2);
48604 {
48605 PyThreadState* __tstate = wxPyBeginAllowThreads();
48606 (arg1)->SetOrientation(arg2);
48607 wxPyEndAllowThreads(__tstate);
48608 if (PyErr_Occurred()) SWIG_fail;
48609 }
48610 resultobj = SWIG_Py_Void();
48611 return resultobj;
48612 fail:
48613 return NULL;
48614 }
48615
48616
48617 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48618 PyObject *obj;
48619 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48620 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
48621 return SWIG_Py_Void();
48622 }
48623
48624 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48625 return SWIG_Python_InitShadowInstance(args);
48626 }
48627
48628 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48629 PyObject *resultobj = 0;
48630 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
48631 int arg2 = (int) wxHORIZONTAL ;
48632 wxStaticBoxSizer *result = 0 ;
48633 void *argp1 = 0 ;
48634 int res1 = 0 ;
48635 int val2 ;
48636 int ecode2 = 0 ;
48637 PyObject * obj0 = 0 ;
48638 PyObject * obj1 = 0 ;
48639 char * kwnames[] = {
48640 (char *) "box",(char *) "orient", NULL
48641 };
48642
48643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
48644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
48645 if (!SWIG_IsOK(res1)) {
48646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
48647 }
48648 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
48649 if (obj1) {
48650 ecode2 = SWIG_AsVal_int(obj1, &val2);
48651 if (!SWIG_IsOK(ecode2)) {
48652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
48653 }
48654 arg2 = static_cast< int >(val2);
48655 }
48656 {
48657 PyThreadState* __tstate = wxPyBeginAllowThreads();
48658 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
48659 wxPyEndAllowThreads(__tstate);
48660 if (PyErr_Occurred()) SWIG_fail;
48661 }
48662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
48663 return resultobj;
48664 fail:
48665 return NULL;
48666 }
48667
48668
48669 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48670 PyObject *resultobj = 0;
48671 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
48672 wxStaticBox *result = 0 ;
48673 void *argp1 = 0 ;
48674 int res1 = 0 ;
48675 PyObject *swig_obj[1] ;
48676
48677 if (!args) SWIG_fail;
48678 swig_obj[0] = args;
48679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
48680 if (!SWIG_IsOK(res1)) {
48681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
48682 }
48683 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
48684 {
48685 PyThreadState* __tstate = wxPyBeginAllowThreads();
48686 result = (wxStaticBox *)(arg1)->GetStaticBox();
48687 wxPyEndAllowThreads(__tstate);
48688 if (PyErr_Occurred()) SWIG_fail;
48689 }
48690 {
48691 resultobj = wxPyMake_wxObject(result, (bool)0);
48692 }
48693 return resultobj;
48694 fail:
48695 return NULL;
48696 }
48697
48698
48699 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48700 PyObject *obj;
48701 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48702 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
48703 return SWIG_Py_Void();
48704 }
48705
48706 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48707 return SWIG_Python_InitShadowInstance(args);
48708 }
48709
48710 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48711 PyObject *resultobj = 0;
48712 int arg1 = (int) 1 ;
48713 int arg2 = (int) 0 ;
48714 int arg3 = (int) 0 ;
48715 int arg4 = (int) 0 ;
48716 wxGridSizer *result = 0 ;
48717 int val1 ;
48718 int ecode1 = 0 ;
48719 int val2 ;
48720 int ecode2 = 0 ;
48721 int val3 ;
48722 int ecode3 = 0 ;
48723 int val4 ;
48724 int ecode4 = 0 ;
48725 PyObject * obj0 = 0 ;
48726 PyObject * obj1 = 0 ;
48727 PyObject * obj2 = 0 ;
48728 PyObject * obj3 = 0 ;
48729 char * kwnames[] = {
48730 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48731 };
48732
48733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48734 if (obj0) {
48735 ecode1 = SWIG_AsVal_int(obj0, &val1);
48736 if (!SWIG_IsOK(ecode1)) {
48737 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
48738 }
48739 arg1 = static_cast< int >(val1);
48740 }
48741 if (obj1) {
48742 ecode2 = SWIG_AsVal_int(obj1, &val2);
48743 if (!SWIG_IsOK(ecode2)) {
48744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
48745 }
48746 arg2 = static_cast< int >(val2);
48747 }
48748 if (obj2) {
48749 ecode3 = SWIG_AsVal_int(obj2, &val3);
48750 if (!SWIG_IsOK(ecode3)) {
48751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
48752 }
48753 arg3 = static_cast< int >(val3);
48754 }
48755 if (obj3) {
48756 ecode4 = SWIG_AsVal_int(obj3, &val4);
48757 if (!SWIG_IsOK(ecode4)) {
48758 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
48759 }
48760 arg4 = static_cast< int >(val4);
48761 }
48762 {
48763 PyThreadState* __tstate = wxPyBeginAllowThreads();
48764 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
48765 wxPyEndAllowThreads(__tstate);
48766 if (PyErr_Occurred()) SWIG_fail;
48767 }
48768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
48769 return resultobj;
48770 fail:
48771 return NULL;
48772 }
48773
48774
48775 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48776 PyObject *resultobj = 0;
48777 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48778 int arg2 ;
48779 void *argp1 = 0 ;
48780 int res1 = 0 ;
48781 int val2 ;
48782 int ecode2 = 0 ;
48783 PyObject * obj0 = 0 ;
48784 PyObject * obj1 = 0 ;
48785 char * kwnames[] = {
48786 (char *) "self",(char *) "cols", NULL
48787 };
48788
48789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
48790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48791 if (!SWIG_IsOK(res1)) {
48792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48793 }
48794 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48795 ecode2 = SWIG_AsVal_int(obj1, &val2);
48796 if (!SWIG_IsOK(ecode2)) {
48797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
48798 }
48799 arg2 = static_cast< int >(val2);
48800 {
48801 PyThreadState* __tstate = wxPyBeginAllowThreads();
48802 (arg1)->SetCols(arg2);
48803 wxPyEndAllowThreads(__tstate);
48804 if (PyErr_Occurred()) SWIG_fail;
48805 }
48806 resultobj = SWIG_Py_Void();
48807 return resultobj;
48808 fail:
48809 return NULL;
48810 }
48811
48812
48813 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48814 PyObject *resultobj = 0;
48815 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48816 int arg2 ;
48817 void *argp1 = 0 ;
48818 int res1 = 0 ;
48819 int val2 ;
48820 int ecode2 = 0 ;
48821 PyObject * obj0 = 0 ;
48822 PyObject * obj1 = 0 ;
48823 char * kwnames[] = {
48824 (char *) "self",(char *) "rows", NULL
48825 };
48826
48827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
48828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48829 if (!SWIG_IsOK(res1)) {
48830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48831 }
48832 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48833 ecode2 = SWIG_AsVal_int(obj1, &val2);
48834 if (!SWIG_IsOK(ecode2)) {
48835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
48836 }
48837 arg2 = static_cast< int >(val2);
48838 {
48839 PyThreadState* __tstate = wxPyBeginAllowThreads();
48840 (arg1)->SetRows(arg2);
48841 wxPyEndAllowThreads(__tstate);
48842 if (PyErr_Occurred()) SWIG_fail;
48843 }
48844 resultobj = SWIG_Py_Void();
48845 return resultobj;
48846 fail:
48847 return NULL;
48848 }
48849
48850
48851 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48852 PyObject *resultobj = 0;
48853 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48854 int arg2 ;
48855 void *argp1 = 0 ;
48856 int res1 = 0 ;
48857 int val2 ;
48858 int ecode2 = 0 ;
48859 PyObject * obj0 = 0 ;
48860 PyObject * obj1 = 0 ;
48861 char * kwnames[] = {
48862 (char *) "self",(char *) "gap", NULL
48863 };
48864
48865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
48866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48867 if (!SWIG_IsOK(res1)) {
48868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48869 }
48870 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48871 ecode2 = SWIG_AsVal_int(obj1, &val2);
48872 if (!SWIG_IsOK(ecode2)) {
48873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
48874 }
48875 arg2 = static_cast< int >(val2);
48876 {
48877 PyThreadState* __tstate = wxPyBeginAllowThreads();
48878 (arg1)->SetVGap(arg2);
48879 wxPyEndAllowThreads(__tstate);
48880 if (PyErr_Occurred()) SWIG_fail;
48881 }
48882 resultobj = SWIG_Py_Void();
48883 return resultobj;
48884 fail:
48885 return NULL;
48886 }
48887
48888
48889 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48890 PyObject *resultobj = 0;
48891 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48892 int arg2 ;
48893 void *argp1 = 0 ;
48894 int res1 = 0 ;
48895 int val2 ;
48896 int ecode2 = 0 ;
48897 PyObject * obj0 = 0 ;
48898 PyObject * obj1 = 0 ;
48899 char * kwnames[] = {
48900 (char *) "self",(char *) "gap", NULL
48901 };
48902
48903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
48904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48905 if (!SWIG_IsOK(res1)) {
48906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48907 }
48908 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48909 ecode2 = SWIG_AsVal_int(obj1, &val2);
48910 if (!SWIG_IsOK(ecode2)) {
48911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
48912 }
48913 arg2 = static_cast< int >(val2);
48914 {
48915 PyThreadState* __tstate = wxPyBeginAllowThreads();
48916 (arg1)->SetHGap(arg2);
48917 wxPyEndAllowThreads(__tstate);
48918 if (PyErr_Occurred()) SWIG_fail;
48919 }
48920 resultobj = SWIG_Py_Void();
48921 return resultobj;
48922 fail:
48923 return NULL;
48924 }
48925
48926
48927 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48928 PyObject *resultobj = 0;
48929 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48930 int result;
48931 void *argp1 = 0 ;
48932 int res1 = 0 ;
48933 PyObject *swig_obj[1] ;
48934
48935 if (!args) SWIG_fail;
48936 swig_obj[0] = args;
48937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48938 if (!SWIG_IsOK(res1)) {
48939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48940 }
48941 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48942 {
48943 PyThreadState* __tstate = wxPyBeginAllowThreads();
48944 result = (int)(arg1)->GetCols();
48945 wxPyEndAllowThreads(__tstate);
48946 if (PyErr_Occurred()) SWIG_fail;
48947 }
48948 resultobj = SWIG_From_int(static_cast< int >(result));
48949 return resultobj;
48950 fail:
48951 return NULL;
48952 }
48953
48954
48955 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48956 PyObject *resultobj = 0;
48957 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48958 int result;
48959 void *argp1 = 0 ;
48960 int res1 = 0 ;
48961 PyObject *swig_obj[1] ;
48962
48963 if (!args) SWIG_fail;
48964 swig_obj[0] = args;
48965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48966 if (!SWIG_IsOK(res1)) {
48967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48968 }
48969 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48970 {
48971 PyThreadState* __tstate = wxPyBeginAllowThreads();
48972 result = (int)(arg1)->GetRows();
48973 wxPyEndAllowThreads(__tstate);
48974 if (PyErr_Occurred()) SWIG_fail;
48975 }
48976 resultobj = SWIG_From_int(static_cast< int >(result));
48977 return resultobj;
48978 fail:
48979 return NULL;
48980 }
48981
48982
48983 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48984 PyObject *resultobj = 0;
48985 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48986 int result;
48987 void *argp1 = 0 ;
48988 int res1 = 0 ;
48989 PyObject *swig_obj[1] ;
48990
48991 if (!args) SWIG_fail;
48992 swig_obj[0] = args;
48993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48994 if (!SWIG_IsOK(res1)) {
48995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48996 }
48997 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48998 {
48999 PyThreadState* __tstate = wxPyBeginAllowThreads();
49000 result = (int)(arg1)->GetVGap();
49001 wxPyEndAllowThreads(__tstate);
49002 if (PyErr_Occurred()) SWIG_fail;
49003 }
49004 resultobj = SWIG_From_int(static_cast< int >(result));
49005 return resultobj;
49006 fail:
49007 return NULL;
49008 }
49009
49010
49011 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49012 PyObject *resultobj = 0;
49013 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
49014 int result;
49015 void *argp1 = 0 ;
49016 int res1 = 0 ;
49017 PyObject *swig_obj[1] ;
49018
49019 if (!args) SWIG_fail;
49020 swig_obj[0] = args;
49021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
49022 if (!SWIG_IsOK(res1)) {
49023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
49024 }
49025 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
49026 {
49027 PyThreadState* __tstate = wxPyBeginAllowThreads();
49028 result = (int)(arg1)->GetHGap();
49029 wxPyEndAllowThreads(__tstate);
49030 if (PyErr_Occurred()) SWIG_fail;
49031 }
49032 resultobj = SWIG_From_int(static_cast< int >(result));
49033 return resultobj;
49034 fail:
49035 return NULL;
49036 }
49037
49038
49039 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49040 PyObject *obj;
49041 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49042 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
49043 return SWIG_Py_Void();
49044 }
49045
49046 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49047 return SWIG_Python_InitShadowInstance(args);
49048 }
49049
49050 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49051 PyObject *resultobj = 0;
49052 int arg1 = (int) 1 ;
49053 int arg2 = (int) 0 ;
49054 int arg3 = (int) 0 ;
49055 int arg4 = (int) 0 ;
49056 wxFlexGridSizer *result = 0 ;
49057 int val1 ;
49058 int ecode1 = 0 ;
49059 int val2 ;
49060 int ecode2 = 0 ;
49061 int val3 ;
49062 int ecode3 = 0 ;
49063 int val4 ;
49064 int ecode4 = 0 ;
49065 PyObject * obj0 = 0 ;
49066 PyObject * obj1 = 0 ;
49067 PyObject * obj2 = 0 ;
49068 PyObject * obj3 = 0 ;
49069 char * kwnames[] = {
49070 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
49071 };
49072
49073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
49074 if (obj0) {
49075 ecode1 = SWIG_AsVal_int(obj0, &val1);
49076 if (!SWIG_IsOK(ecode1)) {
49077 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
49078 }
49079 arg1 = static_cast< int >(val1);
49080 }
49081 if (obj1) {
49082 ecode2 = SWIG_AsVal_int(obj1, &val2);
49083 if (!SWIG_IsOK(ecode2)) {
49084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
49085 }
49086 arg2 = static_cast< int >(val2);
49087 }
49088 if (obj2) {
49089 ecode3 = SWIG_AsVal_int(obj2, &val3);
49090 if (!SWIG_IsOK(ecode3)) {
49091 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
49092 }
49093 arg3 = static_cast< int >(val3);
49094 }
49095 if (obj3) {
49096 ecode4 = SWIG_AsVal_int(obj3, &val4);
49097 if (!SWIG_IsOK(ecode4)) {
49098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
49099 }
49100 arg4 = static_cast< int >(val4);
49101 }
49102 {
49103 PyThreadState* __tstate = wxPyBeginAllowThreads();
49104 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
49105 wxPyEndAllowThreads(__tstate);
49106 if (PyErr_Occurred()) SWIG_fail;
49107 }
49108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
49109 return resultobj;
49110 fail:
49111 return NULL;
49112 }
49113
49114
49115 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49116 PyObject *resultobj = 0;
49117 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49118 size_t arg2 ;
49119 int arg3 = (int) 0 ;
49120 void *argp1 = 0 ;
49121 int res1 = 0 ;
49122 size_t val2 ;
49123 int ecode2 = 0 ;
49124 int val3 ;
49125 int ecode3 = 0 ;
49126 PyObject * obj0 = 0 ;
49127 PyObject * obj1 = 0 ;
49128 PyObject * obj2 = 0 ;
49129 char * kwnames[] = {
49130 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49131 };
49132
49133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49135 if (!SWIG_IsOK(res1)) {
49136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49137 }
49138 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49139 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49140 if (!SWIG_IsOK(ecode2)) {
49141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49142 }
49143 arg2 = static_cast< size_t >(val2);
49144 if (obj2) {
49145 ecode3 = SWIG_AsVal_int(obj2, &val3);
49146 if (!SWIG_IsOK(ecode3)) {
49147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
49148 }
49149 arg3 = static_cast< int >(val3);
49150 }
49151 {
49152 PyThreadState* __tstate = wxPyBeginAllowThreads();
49153 (arg1)->AddGrowableRow(arg2,arg3);
49154 wxPyEndAllowThreads(__tstate);
49155 if (PyErr_Occurred()) SWIG_fail;
49156 }
49157 resultobj = SWIG_Py_Void();
49158 return resultobj;
49159 fail:
49160 return NULL;
49161 }
49162
49163
49164 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49165 PyObject *resultobj = 0;
49166 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49167 size_t arg2 ;
49168 void *argp1 = 0 ;
49169 int res1 = 0 ;
49170 size_t val2 ;
49171 int ecode2 = 0 ;
49172 PyObject * obj0 = 0 ;
49173 PyObject * obj1 = 0 ;
49174 char * kwnames[] = {
49175 (char *) "self",(char *) "idx", NULL
49176 };
49177
49178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
49179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49180 if (!SWIG_IsOK(res1)) {
49181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49182 }
49183 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49184 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49185 if (!SWIG_IsOK(ecode2)) {
49186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
49187 }
49188 arg2 = static_cast< size_t >(val2);
49189 {
49190 PyThreadState* __tstate = wxPyBeginAllowThreads();
49191 (arg1)->RemoveGrowableRow(arg2);
49192 wxPyEndAllowThreads(__tstate);
49193 if (PyErr_Occurred()) SWIG_fail;
49194 }
49195 resultobj = SWIG_Py_Void();
49196 return resultobj;
49197 fail:
49198 return NULL;
49199 }
49200
49201
49202 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49203 PyObject *resultobj = 0;
49204 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49205 size_t arg2 ;
49206 int arg3 = (int) 0 ;
49207 void *argp1 = 0 ;
49208 int res1 = 0 ;
49209 size_t val2 ;
49210 int ecode2 = 0 ;
49211 int val3 ;
49212 int ecode3 = 0 ;
49213 PyObject * obj0 = 0 ;
49214 PyObject * obj1 = 0 ;
49215 PyObject * obj2 = 0 ;
49216 char * kwnames[] = {
49217 (char *) "self",(char *) "idx",(char *) "proportion", NULL
49218 };
49219
49220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49222 if (!SWIG_IsOK(res1)) {
49223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49224 }
49225 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49226 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49227 if (!SWIG_IsOK(ecode2)) {
49228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49229 }
49230 arg2 = static_cast< size_t >(val2);
49231 if (obj2) {
49232 ecode3 = SWIG_AsVal_int(obj2, &val3);
49233 if (!SWIG_IsOK(ecode3)) {
49234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
49235 }
49236 arg3 = static_cast< int >(val3);
49237 }
49238 {
49239 PyThreadState* __tstate = wxPyBeginAllowThreads();
49240 (arg1)->AddGrowableCol(arg2,arg3);
49241 wxPyEndAllowThreads(__tstate);
49242 if (PyErr_Occurred()) SWIG_fail;
49243 }
49244 resultobj = SWIG_Py_Void();
49245 return resultobj;
49246 fail:
49247 return NULL;
49248 }
49249
49250
49251 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49252 PyObject *resultobj = 0;
49253 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49254 size_t arg2 ;
49255 void *argp1 = 0 ;
49256 int res1 = 0 ;
49257 size_t val2 ;
49258 int ecode2 = 0 ;
49259 PyObject * obj0 = 0 ;
49260 PyObject * obj1 = 0 ;
49261 char * kwnames[] = {
49262 (char *) "self",(char *) "idx", NULL
49263 };
49264
49265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
49266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49267 if (!SWIG_IsOK(res1)) {
49268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49269 }
49270 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49271 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
49272 if (!SWIG_IsOK(ecode2)) {
49273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
49274 }
49275 arg2 = static_cast< size_t >(val2);
49276 {
49277 PyThreadState* __tstate = wxPyBeginAllowThreads();
49278 (arg1)->RemoveGrowableCol(arg2);
49279 wxPyEndAllowThreads(__tstate);
49280 if (PyErr_Occurred()) SWIG_fail;
49281 }
49282 resultobj = SWIG_Py_Void();
49283 return resultobj;
49284 fail:
49285 return NULL;
49286 }
49287
49288
49289 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49290 PyObject *resultobj = 0;
49291 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49292 int arg2 ;
49293 void *argp1 = 0 ;
49294 int res1 = 0 ;
49295 int val2 ;
49296 int ecode2 = 0 ;
49297 PyObject * obj0 = 0 ;
49298 PyObject * obj1 = 0 ;
49299 char * kwnames[] = {
49300 (char *) "self",(char *) "direction", NULL
49301 };
49302
49303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
49304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49305 if (!SWIG_IsOK(res1)) {
49306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49307 }
49308 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49309 ecode2 = SWIG_AsVal_int(obj1, &val2);
49310 if (!SWIG_IsOK(ecode2)) {
49311 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
49312 }
49313 arg2 = static_cast< int >(val2);
49314 {
49315 PyThreadState* __tstate = wxPyBeginAllowThreads();
49316 (arg1)->SetFlexibleDirection(arg2);
49317 wxPyEndAllowThreads(__tstate);
49318 if (PyErr_Occurred()) SWIG_fail;
49319 }
49320 resultobj = SWIG_Py_Void();
49321 return resultobj;
49322 fail:
49323 return NULL;
49324 }
49325
49326
49327 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49328 PyObject *resultobj = 0;
49329 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49330 int result;
49331 void *argp1 = 0 ;
49332 int res1 = 0 ;
49333 PyObject *swig_obj[1] ;
49334
49335 if (!args) SWIG_fail;
49336 swig_obj[0] = args;
49337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49338 if (!SWIG_IsOK(res1)) {
49339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49340 }
49341 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49342 {
49343 PyThreadState* __tstate = wxPyBeginAllowThreads();
49344 result = (int)(arg1)->GetFlexibleDirection();
49345 wxPyEndAllowThreads(__tstate);
49346 if (PyErr_Occurred()) SWIG_fail;
49347 }
49348 resultobj = SWIG_From_int(static_cast< int >(result));
49349 return resultobj;
49350 fail:
49351 return NULL;
49352 }
49353
49354
49355 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49356 PyObject *resultobj = 0;
49357 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49358 wxFlexSizerGrowMode arg2 ;
49359 void *argp1 = 0 ;
49360 int res1 = 0 ;
49361 int val2 ;
49362 int ecode2 = 0 ;
49363 PyObject * obj0 = 0 ;
49364 PyObject * obj1 = 0 ;
49365 char * kwnames[] = {
49366 (char *) "self",(char *) "mode", NULL
49367 };
49368
49369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
49370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49371 if (!SWIG_IsOK(res1)) {
49372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49373 }
49374 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49375 ecode2 = SWIG_AsVal_int(obj1, &val2);
49376 if (!SWIG_IsOK(ecode2)) {
49377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
49378 }
49379 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
49380 {
49381 PyThreadState* __tstate = wxPyBeginAllowThreads();
49382 (arg1)->SetNonFlexibleGrowMode(arg2);
49383 wxPyEndAllowThreads(__tstate);
49384 if (PyErr_Occurred()) SWIG_fail;
49385 }
49386 resultobj = SWIG_Py_Void();
49387 return resultobj;
49388 fail:
49389 return NULL;
49390 }
49391
49392
49393 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49394 PyObject *resultobj = 0;
49395 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49396 wxFlexSizerGrowMode result;
49397 void *argp1 = 0 ;
49398 int res1 = 0 ;
49399 PyObject *swig_obj[1] ;
49400
49401 if (!args) SWIG_fail;
49402 swig_obj[0] = args;
49403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49404 if (!SWIG_IsOK(res1)) {
49405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
49406 }
49407 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49408 {
49409 PyThreadState* __tstate = wxPyBeginAllowThreads();
49410 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
49411 wxPyEndAllowThreads(__tstate);
49412 if (PyErr_Occurred()) SWIG_fail;
49413 }
49414 resultobj = SWIG_From_int(static_cast< int >(result));
49415 return resultobj;
49416 fail:
49417 return NULL;
49418 }
49419
49420
49421 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49422 PyObject *resultobj = 0;
49423 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49424 wxArrayInt *result = 0 ;
49425 void *argp1 = 0 ;
49426 int res1 = 0 ;
49427 PyObject *swig_obj[1] ;
49428
49429 if (!args) SWIG_fail;
49430 swig_obj[0] = args;
49431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49432 if (!SWIG_IsOK(res1)) {
49433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49434 }
49435 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49436 {
49437 PyThreadState* __tstate = wxPyBeginAllowThreads();
49438 {
49439 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
49440 result = (wxArrayInt *) &_result_ref;
49441 }
49442 wxPyEndAllowThreads(__tstate);
49443 if (PyErr_Occurred()) SWIG_fail;
49444 }
49445 {
49446 resultobj = PyList_New(0);
49447 size_t idx;
49448 for (idx = 0; idx < result->GetCount(); idx += 1) {
49449 PyObject* val = PyInt_FromLong( result->Item(idx) );
49450 PyList_Append(resultobj, val);
49451 Py_DECREF(val);
49452 }
49453 }
49454 return resultobj;
49455 fail:
49456 return NULL;
49457 }
49458
49459
49460 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49461 PyObject *resultobj = 0;
49462 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
49463 wxArrayInt *result = 0 ;
49464 void *argp1 = 0 ;
49465 int res1 = 0 ;
49466 PyObject *swig_obj[1] ;
49467
49468 if (!args) SWIG_fail;
49469 swig_obj[0] = args;
49470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
49471 if (!SWIG_IsOK(res1)) {
49472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
49473 }
49474 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
49475 {
49476 PyThreadState* __tstate = wxPyBeginAllowThreads();
49477 {
49478 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
49479 result = (wxArrayInt *) &_result_ref;
49480 }
49481 wxPyEndAllowThreads(__tstate);
49482 if (PyErr_Occurred()) SWIG_fail;
49483 }
49484 {
49485 resultobj = PyList_New(0);
49486 size_t idx;
49487 for (idx = 0; idx < result->GetCount(); idx += 1) {
49488 PyObject* val = PyInt_FromLong( result->Item(idx) );
49489 PyList_Append(resultobj, val);
49490 Py_DECREF(val);
49491 }
49492 }
49493 return resultobj;
49494 fail:
49495 return NULL;
49496 }
49497
49498
49499 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49500 PyObject *obj;
49501 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49502 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
49503 return SWIG_Py_Void();
49504 }
49505
49506 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49507 return SWIG_Python_InitShadowInstance(args);
49508 }
49509
49510 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49511 PyObject *resultobj = 0;
49512 wxStdDialogButtonSizer *result = 0 ;
49513
49514 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
49515 {
49516 PyThreadState* __tstate = wxPyBeginAllowThreads();
49517 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
49518 wxPyEndAllowThreads(__tstate);
49519 if (PyErr_Occurred()) SWIG_fail;
49520 }
49521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
49522 return resultobj;
49523 fail:
49524 return NULL;
49525 }
49526
49527
49528 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49529 PyObject *resultobj = 0;
49530 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49531 wxButton *arg2 = (wxButton *) 0 ;
49532 void *argp1 = 0 ;
49533 int res1 = 0 ;
49534 void *argp2 = 0 ;
49535 int res2 = 0 ;
49536 PyObject * obj0 = 0 ;
49537 PyObject * obj1 = 0 ;
49538 char * kwnames[] = {
49539 (char *) "self",(char *) "button", NULL
49540 };
49541
49542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
49543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49544 if (!SWIG_IsOK(res1)) {
49545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49546 }
49547 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49548 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49549 if (!SWIG_IsOK(res2)) {
49550 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
49551 }
49552 arg2 = reinterpret_cast< wxButton * >(argp2);
49553 {
49554 PyThreadState* __tstate = wxPyBeginAllowThreads();
49555 (arg1)->AddButton(arg2);
49556 wxPyEndAllowThreads(__tstate);
49557 if (PyErr_Occurred()) SWIG_fail;
49558 }
49559 resultobj = SWIG_Py_Void();
49560 return resultobj;
49561 fail:
49562 return NULL;
49563 }
49564
49565
49566 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49567 PyObject *resultobj = 0;
49568 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49569 void *argp1 = 0 ;
49570 int res1 = 0 ;
49571 PyObject *swig_obj[1] ;
49572
49573 if (!args) SWIG_fail;
49574 swig_obj[0] = args;
49575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49576 if (!SWIG_IsOK(res1)) {
49577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49578 }
49579 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49580 {
49581 PyThreadState* __tstate = wxPyBeginAllowThreads();
49582 (arg1)->Realize();
49583 wxPyEndAllowThreads(__tstate);
49584 if (PyErr_Occurred()) SWIG_fail;
49585 }
49586 resultobj = SWIG_Py_Void();
49587 return resultobj;
49588 fail:
49589 return NULL;
49590 }
49591
49592
49593 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49594 PyObject *resultobj = 0;
49595 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49596 wxButton *arg2 = (wxButton *) 0 ;
49597 void *argp1 = 0 ;
49598 int res1 = 0 ;
49599 void *argp2 = 0 ;
49600 int res2 = 0 ;
49601 PyObject * obj0 = 0 ;
49602 PyObject * obj1 = 0 ;
49603 char * kwnames[] = {
49604 (char *) "self",(char *) "button", NULL
49605 };
49606
49607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49609 if (!SWIG_IsOK(res1)) {
49610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49611 }
49612 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49613 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49614 if (!SWIG_IsOK(res2)) {
49615 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49616 }
49617 arg2 = reinterpret_cast< wxButton * >(argp2);
49618 {
49619 PyThreadState* __tstate = wxPyBeginAllowThreads();
49620 (arg1)->SetAffirmativeButton(arg2);
49621 wxPyEndAllowThreads(__tstate);
49622 if (PyErr_Occurred()) SWIG_fail;
49623 }
49624 resultobj = SWIG_Py_Void();
49625 return resultobj;
49626 fail:
49627 return NULL;
49628 }
49629
49630
49631 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49632 PyObject *resultobj = 0;
49633 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49634 wxButton *arg2 = (wxButton *) 0 ;
49635 void *argp1 = 0 ;
49636 int res1 = 0 ;
49637 void *argp2 = 0 ;
49638 int res2 = 0 ;
49639 PyObject * obj0 = 0 ;
49640 PyObject * obj1 = 0 ;
49641 char * kwnames[] = {
49642 (char *) "self",(char *) "button", NULL
49643 };
49644
49645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
49646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49647 if (!SWIG_IsOK(res1)) {
49648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49649 }
49650 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49652 if (!SWIG_IsOK(res2)) {
49653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
49654 }
49655 arg2 = reinterpret_cast< wxButton * >(argp2);
49656 {
49657 PyThreadState* __tstate = wxPyBeginAllowThreads();
49658 (arg1)->SetNegativeButton(arg2);
49659 wxPyEndAllowThreads(__tstate);
49660 if (PyErr_Occurred()) SWIG_fail;
49661 }
49662 resultobj = SWIG_Py_Void();
49663 return resultobj;
49664 fail:
49665 return NULL;
49666 }
49667
49668
49669 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49670 PyObject *resultobj = 0;
49671 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49672 wxButton *arg2 = (wxButton *) 0 ;
49673 void *argp1 = 0 ;
49674 int res1 = 0 ;
49675 void *argp2 = 0 ;
49676 int res2 = 0 ;
49677 PyObject * obj0 = 0 ;
49678 PyObject * obj1 = 0 ;
49679 char * kwnames[] = {
49680 (char *) "self",(char *) "button", NULL
49681 };
49682
49683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
49684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49685 if (!SWIG_IsOK(res1)) {
49686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
49687 }
49688 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49689 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
49690 if (!SWIG_IsOK(res2)) {
49691 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
49692 }
49693 arg2 = reinterpret_cast< wxButton * >(argp2);
49694 {
49695 PyThreadState* __tstate = wxPyBeginAllowThreads();
49696 (arg1)->SetCancelButton(arg2);
49697 wxPyEndAllowThreads(__tstate);
49698 if (PyErr_Occurred()) SWIG_fail;
49699 }
49700 resultobj = SWIG_Py_Void();
49701 return resultobj;
49702 fail:
49703 return NULL;
49704 }
49705
49706
49707 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(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_GetAffirmativeButton" "', 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)->GetAffirmativeButton();
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_GetApplyButton(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_GetApplyButton" "', 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)->GetApplyButton();
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_GetNegativeButton(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_GetNegativeButton" "', 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)->GetNegativeButton();
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 *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49798 PyObject *resultobj = 0;
49799 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49800 wxButton *result = 0 ;
49801 void *argp1 = 0 ;
49802 int res1 = 0 ;
49803 PyObject *swig_obj[1] ;
49804
49805 if (!args) SWIG_fail;
49806 swig_obj[0] = args;
49807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49808 if (!SWIG_IsOK(res1)) {
49809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49810 }
49811 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49812 {
49813 PyThreadState* __tstate = wxPyBeginAllowThreads();
49814 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
49815 wxPyEndAllowThreads(__tstate);
49816 if (PyErr_Occurred()) SWIG_fail;
49817 }
49818 {
49819 resultobj = wxPyMake_wxObject(result, (bool)0);
49820 }
49821 return resultobj;
49822 fail:
49823 return NULL;
49824 }
49825
49826
49827 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49828 PyObject *resultobj = 0;
49829 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
49830 wxButton *result = 0 ;
49831 void *argp1 = 0 ;
49832 int res1 = 0 ;
49833 PyObject *swig_obj[1] ;
49834
49835 if (!args) SWIG_fail;
49836 swig_obj[0] = args;
49837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
49838 if (!SWIG_IsOK(res1)) {
49839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
49840 }
49841 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
49842 {
49843 PyThreadState* __tstate = wxPyBeginAllowThreads();
49844 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
49845 wxPyEndAllowThreads(__tstate);
49846 if (PyErr_Occurred()) SWIG_fail;
49847 }
49848 {
49849 resultobj = wxPyMake_wxObject(result, (bool)0);
49850 }
49851 return resultobj;
49852 fail:
49853 return NULL;
49854 }
49855
49856
49857 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49858 PyObject *obj;
49859 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49860 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
49861 return SWIG_Py_Void();
49862 }
49863
49864 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49865 return SWIG_Python_InitShadowInstance(args);
49866 }
49867
49868 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49869 PyObject *resultobj = 0;
49870 int arg1 = (int) 0 ;
49871 int arg2 = (int) 0 ;
49872 wxGBPosition *result = 0 ;
49873 int val1 ;
49874 int ecode1 = 0 ;
49875 int val2 ;
49876 int ecode2 = 0 ;
49877 PyObject * obj0 = 0 ;
49878 PyObject * obj1 = 0 ;
49879 char * kwnames[] = {
49880 (char *) "row",(char *) "col", NULL
49881 };
49882
49883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
49884 if (obj0) {
49885 ecode1 = SWIG_AsVal_int(obj0, &val1);
49886 if (!SWIG_IsOK(ecode1)) {
49887 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
49888 }
49889 arg1 = static_cast< int >(val1);
49890 }
49891 if (obj1) {
49892 ecode2 = SWIG_AsVal_int(obj1, &val2);
49893 if (!SWIG_IsOK(ecode2)) {
49894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
49895 }
49896 arg2 = static_cast< int >(val2);
49897 }
49898 {
49899 PyThreadState* __tstate = wxPyBeginAllowThreads();
49900 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
49901 wxPyEndAllowThreads(__tstate);
49902 if (PyErr_Occurred()) SWIG_fail;
49903 }
49904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
49905 return resultobj;
49906 fail:
49907 return NULL;
49908 }
49909
49910
49911 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49912 PyObject *resultobj = 0;
49913 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49914 void *argp1 = 0 ;
49915 int res1 = 0 ;
49916 PyObject *swig_obj[1] ;
49917
49918 if (!args) SWIG_fail;
49919 swig_obj[0] = args;
49920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
49921 if (!SWIG_IsOK(res1)) {
49922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49923 }
49924 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49925 {
49926 PyThreadState* __tstate = wxPyBeginAllowThreads();
49927 delete arg1;
49928
49929 wxPyEndAllowThreads(__tstate);
49930 if (PyErr_Occurred()) SWIG_fail;
49931 }
49932 resultobj = SWIG_Py_Void();
49933 return resultobj;
49934 fail:
49935 return NULL;
49936 }
49937
49938
49939 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49940 PyObject *resultobj = 0;
49941 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49942 int result;
49943 void *argp1 = 0 ;
49944 int res1 = 0 ;
49945 PyObject *swig_obj[1] ;
49946
49947 if (!args) SWIG_fail;
49948 swig_obj[0] = args;
49949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49950 if (!SWIG_IsOK(res1)) {
49951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49952 }
49953 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49954 {
49955 PyThreadState* __tstate = wxPyBeginAllowThreads();
49956 result = (int)((wxGBPosition const *)arg1)->GetRow();
49957 wxPyEndAllowThreads(__tstate);
49958 if (PyErr_Occurred()) SWIG_fail;
49959 }
49960 resultobj = SWIG_From_int(static_cast< int >(result));
49961 return resultobj;
49962 fail:
49963 return NULL;
49964 }
49965
49966
49967 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49968 PyObject *resultobj = 0;
49969 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49970 int result;
49971 void *argp1 = 0 ;
49972 int res1 = 0 ;
49973 PyObject *swig_obj[1] ;
49974
49975 if (!args) SWIG_fail;
49976 swig_obj[0] = args;
49977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49978 if (!SWIG_IsOK(res1)) {
49979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49980 }
49981 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49982 {
49983 PyThreadState* __tstate = wxPyBeginAllowThreads();
49984 result = (int)((wxGBPosition const *)arg1)->GetCol();
49985 wxPyEndAllowThreads(__tstate);
49986 if (PyErr_Occurred()) SWIG_fail;
49987 }
49988 resultobj = SWIG_From_int(static_cast< int >(result));
49989 return resultobj;
49990 fail:
49991 return NULL;
49992 }
49993
49994
49995 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49996 PyObject *resultobj = 0;
49997 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49998 int arg2 ;
49999 void *argp1 = 0 ;
50000 int res1 = 0 ;
50001 int val2 ;
50002 int ecode2 = 0 ;
50003 PyObject * obj0 = 0 ;
50004 PyObject * obj1 = 0 ;
50005 char * kwnames[] = {
50006 (char *) "self",(char *) "row", NULL
50007 };
50008
50009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
50010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50011 if (!SWIG_IsOK(res1)) {
50012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50013 }
50014 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50015 ecode2 = SWIG_AsVal_int(obj1, &val2);
50016 if (!SWIG_IsOK(ecode2)) {
50017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
50018 }
50019 arg2 = static_cast< int >(val2);
50020 {
50021 PyThreadState* __tstate = wxPyBeginAllowThreads();
50022 (arg1)->SetRow(arg2);
50023 wxPyEndAllowThreads(__tstate);
50024 if (PyErr_Occurred()) SWIG_fail;
50025 }
50026 resultobj = SWIG_Py_Void();
50027 return resultobj;
50028 fail:
50029 return NULL;
50030 }
50031
50032
50033 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50034 PyObject *resultobj = 0;
50035 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50036 int arg2 ;
50037 void *argp1 = 0 ;
50038 int res1 = 0 ;
50039 int val2 ;
50040 int ecode2 = 0 ;
50041 PyObject * obj0 = 0 ;
50042 PyObject * obj1 = 0 ;
50043 char * kwnames[] = {
50044 (char *) "self",(char *) "col", NULL
50045 };
50046
50047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
50048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50049 if (!SWIG_IsOK(res1)) {
50050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50051 }
50052 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50053 ecode2 = SWIG_AsVal_int(obj1, &val2);
50054 if (!SWIG_IsOK(ecode2)) {
50055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
50056 }
50057 arg2 = static_cast< int >(val2);
50058 {
50059 PyThreadState* __tstate = wxPyBeginAllowThreads();
50060 (arg1)->SetCol(arg2);
50061 wxPyEndAllowThreads(__tstate);
50062 if (PyErr_Occurred()) SWIG_fail;
50063 }
50064 resultobj = SWIG_Py_Void();
50065 return resultobj;
50066 fail:
50067 return NULL;
50068 }
50069
50070
50071 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50072 PyObject *resultobj = 0;
50073 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50074 PyObject *arg2 = (PyObject *) 0 ;
50075 bool result;
50076 void *argp1 = 0 ;
50077 int res1 = 0 ;
50078 PyObject * obj0 = 0 ;
50079 PyObject * obj1 = 0 ;
50080 char * kwnames[] = {
50081 (char *) "self",(char *) "other", NULL
50082 };
50083
50084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50086 if (!SWIG_IsOK(res1)) {
50087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50088 }
50089 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50090 arg2 = obj1;
50091 {
50092 result = (bool)wxGBPosition___eq__(arg1,arg2);
50093 if (PyErr_Occurred()) SWIG_fail;
50094 }
50095 {
50096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50097 }
50098 return resultobj;
50099 fail:
50100 return NULL;
50101 }
50102
50103
50104 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50105 PyObject *resultobj = 0;
50106 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50107 PyObject *arg2 = (PyObject *) 0 ;
50108 bool result;
50109 void *argp1 = 0 ;
50110 int res1 = 0 ;
50111 PyObject * obj0 = 0 ;
50112 PyObject * obj1 = 0 ;
50113 char * kwnames[] = {
50114 (char *) "self",(char *) "other", NULL
50115 };
50116
50117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50119 if (!SWIG_IsOK(res1)) {
50120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50121 }
50122 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50123 arg2 = obj1;
50124 {
50125 result = (bool)wxGBPosition___ne__(arg1,arg2);
50126 if (PyErr_Occurred()) SWIG_fail;
50127 }
50128 {
50129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50130 }
50131 return resultobj;
50132 fail:
50133 return NULL;
50134 }
50135
50136
50137 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50138 PyObject *resultobj = 0;
50139 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50140 int arg2 = (int) 0 ;
50141 int arg3 = (int) 0 ;
50142 void *argp1 = 0 ;
50143 int res1 = 0 ;
50144 int val2 ;
50145 int ecode2 = 0 ;
50146 int val3 ;
50147 int ecode3 = 0 ;
50148 PyObject * obj0 = 0 ;
50149 PyObject * obj1 = 0 ;
50150 PyObject * obj2 = 0 ;
50151 char * kwnames[] = {
50152 (char *) "self",(char *) "row",(char *) "col", NULL
50153 };
50154
50155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50157 if (!SWIG_IsOK(res1)) {
50158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50159 }
50160 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50161 if (obj1) {
50162 ecode2 = SWIG_AsVal_int(obj1, &val2);
50163 if (!SWIG_IsOK(ecode2)) {
50164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
50165 }
50166 arg2 = static_cast< int >(val2);
50167 }
50168 if (obj2) {
50169 ecode3 = SWIG_AsVal_int(obj2, &val3);
50170 if (!SWIG_IsOK(ecode3)) {
50171 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
50172 }
50173 arg3 = static_cast< int >(val3);
50174 }
50175 {
50176 PyThreadState* __tstate = wxPyBeginAllowThreads();
50177 wxGBPosition_Set(arg1,arg2,arg3);
50178 wxPyEndAllowThreads(__tstate);
50179 if (PyErr_Occurred()) SWIG_fail;
50180 }
50181 resultobj = SWIG_Py_Void();
50182 return resultobj;
50183 fail:
50184 return NULL;
50185 }
50186
50187
50188 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50189 PyObject *resultobj = 0;
50190 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
50191 PyObject *result = 0 ;
50192 void *argp1 = 0 ;
50193 int res1 = 0 ;
50194 PyObject *swig_obj[1] ;
50195
50196 if (!args) SWIG_fail;
50197 swig_obj[0] = args;
50198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
50199 if (!SWIG_IsOK(res1)) {
50200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
50201 }
50202 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
50203 {
50204 PyThreadState* __tstate = wxPyBeginAllowThreads();
50205 result = (PyObject *)wxGBPosition_Get(arg1);
50206 wxPyEndAllowThreads(__tstate);
50207 if (PyErr_Occurred()) SWIG_fail;
50208 }
50209 resultobj = result;
50210 return resultobj;
50211 fail:
50212 return NULL;
50213 }
50214
50215
50216 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50217 PyObject *obj;
50218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50219 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
50220 return SWIG_Py_Void();
50221 }
50222
50223 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50224 return SWIG_Python_InitShadowInstance(args);
50225 }
50226
50227 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50228 PyObject *resultobj = 0;
50229 int arg1 = (int) 1 ;
50230 int arg2 = (int) 1 ;
50231 wxGBSpan *result = 0 ;
50232 int val1 ;
50233 int ecode1 = 0 ;
50234 int val2 ;
50235 int ecode2 = 0 ;
50236 PyObject * obj0 = 0 ;
50237 PyObject * obj1 = 0 ;
50238 char * kwnames[] = {
50239 (char *) "rowspan",(char *) "colspan", NULL
50240 };
50241
50242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50243 if (obj0) {
50244 ecode1 = SWIG_AsVal_int(obj0, &val1);
50245 if (!SWIG_IsOK(ecode1)) {
50246 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
50247 }
50248 arg1 = static_cast< int >(val1);
50249 }
50250 if (obj1) {
50251 ecode2 = SWIG_AsVal_int(obj1, &val2);
50252 if (!SWIG_IsOK(ecode2)) {
50253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
50254 }
50255 arg2 = static_cast< int >(val2);
50256 }
50257 {
50258 PyThreadState* __tstate = wxPyBeginAllowThreads();
50259 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
50260 wxPyEndAllowThreads(__tstate);
50261 if (PyErr_Occurred()) SWIG_fail;
50262 }
50263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
50264 return resultobj;
50265 fail:
50266 return NULL;
50267 }
50268
50269
50270 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50271 PyObject *resultobj = 0;
50272 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50273 void *argp1 = 0 ;
50274 int res1 = 0 ;
50275 PyObject *swig_obj[1] ;
50276
50277 if (!args) SWIG_fail;
50278 swig_obj[0] = args;
50279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
50280 if (!SWIG_IsOK(res1)) {
50281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50282 }
50283 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50284 {
50285 PyThreadState* __tstate = wxPyBeginAllowThreads();
50286 delete arg1;
50287
50288 wxPyEndAllowThreads(__tstate);
50289 if (PyErr_Occurred()) SWIG_fail;
50290 }
50291 resultobj = SWIG_Py_Void();
50292 return resultobj;
50293 fail:
50294 return NULL;
50295 }
50296
50297
50298 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50299 PyObject *resultobj = 0;
50300 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50301 int result;
50302 void *argp1 = 0 ;
50303 int res1 = 0 ;
50304 PyObject *swig_obj[1] ;
50305
50306 if (!args) SWIG_fail;
50307 swig_obj[0] = args;
50308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50309 if (!SWIG_IsOK(res1)) {
50310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50311 }
50312 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50313 {
50314 PyThreadState* __tstate = wxPyBeginAllowThreads();
50315 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
50316 wxPyEndAllowThreads(__tstate);
50317 if (PyErr_Occurred()) SWIG_fail;
50318 }
50319 resultobj = SWIG_From_int(static_cast< int >(result));
50320 return resultobj;
50321 fail:
50322 return NULL;
50323 }
50324
50325
50326 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50327 PyObject *resultobj = 0;
50328 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50329 int result;
50330 void *argp1 = 0 ;
50331 int res1 = 0 ;
50332 PyObject *swig_obj[1] ;
50333
50334 if (!args) SWIG_fail;
50335 swig_obj[0] = args;
50336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50337 if (!SWIG_IsOK(res1)) {
50338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
50339 }
50340 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50341 {
50342 PyThreadState* __tstate = wxPyBeginAllowThreads();
50343 result = (int)((wxGBSpan const *)arg1)->GetColspan();
50344 wxPyEndAllowThreads(__tstate);
50345 if (PyErr_Occurred()) SWIG_fail;
50346 }
50347 resultobj = SWIG_From_int(static_cast< int >(result));
50348 return resultobj;
50349 fail:
50350 return NULL;
50351 }
50352
50353
50354 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50355 PyObject *resultobj = 0;
50356 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50357 int arg2 ;
50358 void *argp1 = 0 ;
50359 int res1 = 0 ;
50360 int val2 ;
50361 int ecode2 = 0 ;
50362 PyObject * obj0 = 0 ;
50363 PyObject * obj1 = 0 ;
50364 char * kwnames[] = {
50365 (char *) "self",(char *) "rowspan", NULL
50366 };
50367
50368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
50369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50370 if (!SWIG_IsOK(res1)) {
50371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50372 }
50373 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50374 ecode2 = SWIG_AsVal_int(obj1, &val2);
50375 if (!SWIG_IsOK(ecode2)) {
50376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
50377 }
50378 arg2 = static_cast< int >(val2);
50379 {
50380 PyThreadState* __tstate = wxPyBeginAllowThreads();
50381 (arg1)->SetRowspan(arg2);
50382 wxPyEndAllowThreads(__tstate);
50383 if (PyErr_Occurred()) SWIG_fail;
50384 }
50385 resultobj = SWIG_Py_Void();
50386 return resultobj;
50387 fail:
50388 return NULL;
50389 }
50390
50391
50392 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50393 PyObject *resultobj = 0;
50394 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50395 int arg2 ;
50396 void *argp1 = 0 ;
50397 int res1 = 0 ;
50398 int val2 ;
50399 int ecode2 = 0 ;
50400 PyObject * obj0 = 0 ;
50401 PyObject * obj1 = 0 ;
50402 char * kwnames[] = {
50403 (char *) "self",(char *) "colspan", NULL
50404 };
50405
50406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
50407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50408 if (!SWIG_IsOK(res1)) {
50409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50410 }
50411 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50412 ecode2 = SWIG_AsVal_int(obj1, &val2);
50413 if (!SWIG_IsOK(ecode2)) {
50414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
50415 }
50416 arg2 = static_cast< int >(val2);
50417 {
50418 PyThreadState* __tstate = wxPyBeginAllowThreads();
50419 (arg1)->SetColspan(arg2);
50420 wxPyEndAllowThreads(__tstate);
50421 if (PyErr_Occurred()) SWIG_fail;
50422 }
50423 resultobj = SWIG_Py_Void();
50424 return resultobj;
50425 fail:
50426 return NULL;
50427 }
50428
50429
50430 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50431 PyObject *resultobj = 0;
50432 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50433 PyObject *arg2 = (PyObject *) 0 ;
50434 bool result;
50435 void *argp1 = 0 ;
50436 int res1 = 0 ;
50437 PyObject * obj0 = 0 ;
50438 PyObject * obj1 = 0 ;
50439 char * kwnames[] = {
50440 (char *) "self",(char *) "other", NULL
50441 };
50442
50443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
50444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50445 if (!SWIG_IsOK(res1)) {
50446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50447 }
50448 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50449 arg2 = obj1;
50450 {
50451 result = (bool)wxGBSpan___eq__(arg1,arg2);
50452 if (PyErr_Occurred()) SWIG_fail;
50453 }
50454 {
50455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50456 }
50457 return resultobj;
50458 fail:
50459 return NULL;
50460 }
50461
50462
50463 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50464 PyObject *resultobj = 0;
50465 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50466 PyObject *arg2 = (PyObject *) 0 ;
50467 bool result;
50468 void *argp1 = 0 ;
50469 int res1 = 0 ;
50470 PyObject * obj0 = 0 ;
50471 PyObject * obj1 = 0 ;
50472 char * kwnames[] = {
50473 (char *) "self",(char *) "other", NULL
50474 };
50475
50476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
50477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50478 if (!SWIG_IsOK(res1)) {
50479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50480 }
50481 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50482 arg2 = obj1;
50483 {
50484 result = (bool)wxGBSpan___ne__(arg1,arg2);
50485 if (PyErr_Occurred()) SWIG_fail;
50486 }
50487 {
50488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50489 }
50490 return resultobj;
50491 fail:
50492 return NULL;
50493 }
50494
50495
50496 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50497 PyObject *resultobj = 0;
50498 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50499 int arg2 = (int) 1 ;
50500 int arg3 = (int) 1 ;
50501 void *argp1 = 0 ;
50502 int res1 = 0 ;
50503 int val2 ;
50504 int ecode2 = 0 ;
50505 int val3 ;
50506 int ecode3 = 0 ;
50507 PyObject * obj0 = 0 ;
50508 PyObject * obj1 = 0 ;
50509 PyObject * obj2 = 0 ;
50510 char * kwnames[] = {
50511 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
50512 };
50513
50514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50516 if (!SWIG_IsOK(res1)) {
50517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50518 }
50519 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50520 if (obj1) {
50521 ecode2 = SWIG_AsVal_int(obj1, &val2);
50522 if (!SWIG_IsOK(ecode2)) {
50523 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
50524 }
50525 arg2 = static_cast< int >(val2);
50526 }
50527 if (obj2) {
50528 ecode3 = SWIG_AsVal_int(obj2, &val3);
50529 if (!SWIG_IsOK(ecode3)) {
50530 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
50531 }
50532 arg3 = static_cast< int >(val3);
50533 }
50534 {
50535 PyThreadState* __tstate = wxPyBeginAllowThreads();
50536 wxGBSpan_Set(arg1,arg2,arg3);
50537 wxPyEndAllowThreads(__tstate);
50538 if (PyErr_Occurred()) SWIG_fail;
50539 }
50540 resultobj = SWIG_Py_Void();
50541 return resultobj;
50542 fail:
50543 return NULL;
50544 }
50545
50546
50547 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50548 PyObject *resultobj = 0;
50549 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
50550 PyObject *result = 0 ;
50551 void *argp1 = 0 ;
50552 int res1 = 0 ;
50553 PyObject *swig_obj[1] ;
50554
50555 if (!args) SWIG_fail;
50556 swig_obj[0] = args;
50557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
50558 if (!SWIG_IsOK(res1)) {
50559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
50560 }
50561 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
50562 {
50563 PyThreadState* __tstate = wxPyBeginAllowThreads();
50564 result = (PyObject *)wxGBSpan_Get(arg1);
50565 wxPyEndAllowThreads(__tstate);
50566 if (PyErr_Occurred()) SWIG_fail;
50567 }
50568 resultobj = result;
50569 return resultobj;
50570 fail:
50571 return NULL;
50572 }
50573
50574
50575 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50576 PyObject *obj;
50577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50578 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
50579 return SWIG_Py_Void();
50580 }
50581
50582 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50583 return SWIG_Python_InitShadowInstance(args);
50584 }
50585
50586 SWIGINTERN int DefaultSpan_set(PyObject *) {
50587 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
50588 return 1;
50589 }
50590
50591
50592 SWIGINTERN PyObject *DefaultSpan_get(void) {
50593 PyObject *pyobj = 0;
50594
50595 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
50596 return pyobj;
50597 }
50598
50599
50600 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50601 PyObject *resultobj = 0;
50602 wxGBSizerItem *result = 0 ;
50603
50604 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
50605 {
50606 PyThreadState* __tstate = wxPyBeginAllowThreads();
50607 result = (wxGBSizerItem *)new wxGBSizerItem();
50608 wxPyEndAllowThreads(__tstate);
50609 if (PyErr_Occurred()) SWIG_fail;
50610 }
50611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
50612 return resultobj;
50613 fail:
50614 return NULL;
50615 }
50616
50617
50618 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50619 PyObject *resultobj = 0;
50620 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50621 void *argp1 = 0 ;
50622 int res1 = 0 ;
50623 PyObject *swig_obj[1] ;
50624
50625 if (!args) SWIG_fail;
50626 swig_obj[0] = args;
50627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50628 if (!SWIG_IsOK(res1)) {
50629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50630 }
50631 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50632 {
50633 PyThreadState* __tstate = wxPyBeginAllowThreads();
50634 delete arg1;
50635
50636 wxPyEndAllowThreads(__tstate);
50637 if (PyErr_Occurred()) SWIG_fail;
50638 }
50639 resultobj = SWIG_Py_Void();
50640 return resultobj;
50641 fail:
50642 return NULL;
50643 }
50644
50645
50646 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50647 PyObject *resultobj = 0;
50648 wxWindow *arg1 = (wxWindow *) 0 ;
50649 wxGBPosition *arg2 = 0 ;
50650 wxGBSpan *arg3 = 0 ;
50651 int arg4 ;
50652 int arg5 ;
50653 PyObject *arg6 = (PyObject *) NULL ;
50654 wxGBSizerItem *result = 0 ;
50655 void *argp1 = 0 ;
50656 int res1 = 0 ;
50657 wxGBPosition temp2 ;
50658 wxGBSpan temp3 ;
50659 int val4 ;
50660 int ecode4 = 0 ;
50661 int val5 ;
50662 int ecode5 = 0 ;
50663 PyObject * obj0 = 0 ;
50664 PyObject * obj1 = 0 ;
50665 PyObject * obj2 = 0 ;
50666 PyObject * obj3 = 0 ;
50667 PyObject * obj4 = 0 ;
50668 PyObject * obj5 = 0 ;
50669 char * kwnames[] = {
50670 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50671 };
50672
50673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50675 if (!SWIG_IsOK(res1)) {
50676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50677 }
50678 arg1 = reinterpret_cast< wxWindow * >(argp1);
50679 {
50680 arg2 = &temp2;
50681 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50682 }
50683 {
50684 arg3 = &temp3;
50685 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50686 }
50687 ecode4 = SWIG_AsVal_int(obj3, &val4);
50688 if (!SWIG_IsOK(ecode4)) {
50689 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50690 }
50691 arg4 = static_cast< int >(val4);
50692 ecode5 = SWIG_AsVal_int(obj4, &val5);
50693 if (!SWIG_IsOK(ecode5)) {
50694 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
50695 }
50696 arg5 = static_cast< int >(val5);
50697 if (obj5) {
50698 arg6 = obj5;
50699 }
50700 {
50701 PyThreadState* __tstate = wxPyBeginAllowThreads();
50702 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50703 wxPyEndAllowThreads(__tstate);
50704 if (PyErr_Occurred()) SWIG_fail;
50705 }
50706 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50707 return resultobj;
50708 fail:
50709 return NULL;
50710 }
50711
50712
50713 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50714 PyObject *resultobj = 0;
50715 wxSizer *arg1 = (wxSizer *) 0 ;
50716 wxGBPosition *arg2 = 0 ;
50717 wxGBSpan *arg3 = 0 ;
50718 int arg4 ;
50719 int arg5 ;
50720 PyObject *arg6 = (PyObject *) NULL ;
50721 wxGBSizerItem *result = 0 ;
50722 int res1 = 0 ;
50723 wxGBPosition temp2 ;
50724 wxGBSpan temp3 ;
50725 int val4 ;
50726 int ecode4 = 0 ;
50727 int val5 ;
50728 int ecode5 = 0 ;
50729 PyObject * obj0 = 0 ;
50730 PyObject * obj1 = 0 ;
50731 PyObject * obj2 = 0 ;
50732 PyObject * obj3 = 0 ;
50733 PyObject * obj4 = 0 ;
50734 PyObject * obj5 = 0 ;
50735 char * kwnames[] = {
50736 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50737 };
50738
50739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50740 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50741 if (!SWIG_IsOK(res1)) {
50742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50743 }
50744 {
50745 arg2 = &temp2;
50746 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50747 }
50748 {
50749 arg3 = &temp3;
50750 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50751 }
50752 ecode4 = SWIG_AsVal_int(obj3, &val4);
50753 if (!SWIG_IsOK(ecode4)) {
50754 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50755 }
50756 arg4 = static_cast< int >(val4);
50757 ecode5 = SWIG_AsVal_int(obj4, &val5);
50758 if (!SWIG_IsOK(ecode5)) {
50759 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
50760 }
50761 arg5 = static_cast< int >(val5);
50762 if (obj5) {
50763 arg6 = obj5;
50764 }
50765 {
50766 PyThreadState* __tstate = wxPyBeginAllowThreads();
50767 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
50768 wxPyEndAllowThreads(__tstate);
50769 if (PyErr_Occurred()) SWIG_fail;
50770 }
50771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50772 return resultobj;
50773 fail:
50774 return NULL;
50775 }
50776
50777
50778 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50779 PyObject *resultobj = 0;
50780 int arg1 ;
50781 int arg2 ;
50782 wxGBPosition *arg3 = 0 ;
50783 wxGBSpan *arg4 = 0 ;
50784 int arg5 ;
50785 int arg6 ;
50786 PyObject *arg7 = (PyObject *) NULL ;
50787 wxGBSizerItem *result = 0 ;
50788 int val1 ;
50789 int ecode1 = 0 ;
50790 int val2 ;
50791 int ecode2 = 0 ;
50792 wxGBPosition temp3 ;
50793 wxGBSpan temp4 ;
50794 int val5 ;
50795 int ecode5 = 0 ;
50796 int val6 ;
50797 int ecode6 = 0 ;
50798 PyObject * obj0 = 0 ;
50799 PyObject * obj1 = 0 ;
50800 PyObject * obj2 = 0 ;
50801 PyObject * obj3 = 0 ;
50802 PyObject * obj4 = 0 ;
50803 PyObject * obj5 = 0 ;
50804 PyObject * obj6 = 0 ;
50805 char * kwnames[] = {
50806 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50807 };
50808
50809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50810 ecode1 = SWIG_AsVal_int(obj0, &val1);
50811 if (!SWIG_IsOK(ecode1)) {
50812 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50813 }
50814 arg1 = static_cast< int >(val1);
50815 ecode2 = SWIG_AsVal_int(obj1, &val2);
50816 if (!SWIG_IsOK(ecode2)) {
50817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50818 }
50819 arg2 = static_cast< int >(val2);
50820 {
50821 arg3 = &temp3;
50822 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50823 }
50824 {
50825 arg4 = &temp4;
50826 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50827 }
50828 ecode5 = SWIG_AsVal_int(obj4, &val5);
50829 if (!SWIG_IsOK(ecode5)) {
50830 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50831 }
50832 arg5 = static_cast< int >(val5);
50833 ecode6 = SWIG_AsVal_int(obj5, &val6);
50834 if (!SWIG_IsOK(ecode6)) {
50835 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
50836 }
50837 arg6 = static_cast< int >(val6);
50838 if (obj6) {
50839 arg7 = obj6;
50840 }
50841 {
50842 PyThreadState* __tstate = wxPyBeginAllowThreads();
50843 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50844 wxPyEndAllowThreads(__tstate);
50845 if (PyErr_Occurred()) SWIG_fail;
50846 }
50847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
50848 return resultobj;
50849 fail:
50850 return NULL;
50851 }
50852
50853
50854 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50855 PyObject *resultobj = 0;
50856 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50857 wxGBPosition result;
50858 void *argp1 = 0 ;
50859 int res1 = 0 ;
50860 PyObject *swig_obj[1] ;
50861
50862 if (!args) SWIG_fail;
50863 swig_obj[0] = args;
50864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50865 if (!SWIG_IsOK(res1)) {
50866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50867 }
50868 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50869 {
50870 PyThreadState* __tstate = wxPyBeginAllowThreads();
50871 result = ((wxGBSizerItem const *)arg1)->GetPos();
50872 wxPyEndAllowThreads(__tstate);
50873 if (PyErr_Occurred()) SWIG_fail;
50874 }
50875 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50876 return resultobj;
50877 fail:
50878 return NULL;
50879 }
50880
50881
50882 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50883 PyObject *resultobj = 0;
50884 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50885 wxGBSpan result;
50886 void *argp1 = 0 ;
50887 int res1 = 0 ;
50888 PyObject *swig_obj[1] ;
50889
50890 if (!args) SWIG_fail;
50891 swig_obj[0] = args;
50892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50893 if (!SWIG_IsOK(res1)) {
50894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50895 }
50896 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50897 {
50898 PyThreadState* __tstate = wxPyBeginAllowThreads();
50899 result = ((wxGBSizerItem const *)arg1)->GetSpan();
50900 wxPyEndAllowThreads(__tstate);
50901 if (PyErr_Occurred()) SWIG_fail;
50902 }
50903 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50904 return resultobj;
50905 fail:
50906 return NULL;
50907 }
50908
50909
50910 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50911 PyObject *resultobj = 0;
50912 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50913 wxGBPosition *arg2 = 0 ;
50914 bool result;
50915 void *argp1 = 0 ;
50916 int res1 = 0 ;
50917 wxGBPosition temp2 ;
50918 PyObject * obj0 = 0 ;
50919 PyObject * obj1 = 0 ;
50920 char * kwnames[] = {
50921 (char *) "self",(char *) "pos", NULL
50922 };
50923
50924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
50925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50926 if (!SWIG_IsOK(res1)) {
50927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50928 }
50929 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50930 {
50931 arg2 = &temp2;
50932 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50933 }
50934 {
50935 PyThreadState* __tstate = wxPyBeginAllowThreads();
50936 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50937 wxPyEndAllowThreads(__tstate);
50938 if (PyErr_Occurred()) SWIG_fail;
50939 }
50940 {
50941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50942 }
50943 return resultobj;
50944 fail:
50945 return NULL;
50946 }
50947
50948
50949 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50950 PyObject *resultobj = 0;
50951 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50952 wxGBSpan *arg2 = 0 ;
50953 bool result;
50954 void *argp1 = 0 ;
50955 int res1 = 0 ;
50956 wxGBSpan temp2 ;
50957 PyObject * obj0 = 0 ;
50958 PyObject * obj1 = 0 ;
50959 char * kwnames[] = {
50960 (char *) "self",(char *) "span", NULL
50961 };
50962
50963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50965 if (!SWIG_IsOK(res1)) {
50966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50967 }
50968 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50969 {
50970 arg2 = &temp2;
50971 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50972 }
50973 {
50974 PyThreadState* __tstate = wxPyBeginAllowThreads();
50975 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50976 wxPyEndAllowThreads(__tstate);
50977 if (PyErr_Occurred()) SWIG_fail;
50978 }
50979 {
50980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50981 }
50982 return resultobj;
50983 fail:
50984 return NULL;
50985 }
50986
50987
50988 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50989 PyObject *resultobj = 0;
50990 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50991 wxGBSizerItem *arg2 = 0 ;
50992 bool result;
50993 void *argp1 = 0 ;
50994 int res1 = 0 ;
50995 void *argp2 = 0 ;
50996 int res2 = 0 ;
50997 PyObject * obj0 = 0 ;
50998 PyObject * obj1 = 0 ;
50999 char * kwnames[] = {
51000 (char *) "self",(char *) "other", NULL
51001 };
51002
51003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
51004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51005 if (!SWIG_IsOK(res1)) {
51006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51007 }
51008 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51009 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
51010 if (!SWIG_IsOK(res2)) {
51011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51012 }
51013 if (!argp2) {
51014 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
51015 }
51016 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51017 {
51018 PyThreadState* __tstate = wxPyBeginAllowThreads();
51019 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
51020 wxPyEndAllowThreads(__tstate);
51021 if (PyErr_Occurred()) SWIG_fail;
51022 }
51023 {
51024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51025 }
51026 return resultobj;
51027 fail:
51028 return NULL;
51029 }
51030
51031
51032 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51033 PyObject *resultobj = 0;
51034 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51035 wxGBPosition *arg2 = 0 ;
51036 wxGBSpan *arg3 = 0 ;
51037 bool result;
51038 void *argp1 = 0 ;
51039 int res1 = 0 ;
51040 wxGBPosition temp2 ;
51041 wxGBSpan temp3 ;
51042 PyObject * obj0 = 0 ;
51043 PyObject * obj1 = 0 ;
51044 PyObject * obj2 = 0 ;
51045 char * kwnames[] = {
51046 (char *) "self",(char *) "pos",(char *) "span", NULL
51047 };
51048
51049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51051 if (!SWIG_IsOK(res1)) {
51052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51053 }
51054 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51055 {
51056 arg2 = &temp2;
51057 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51058 }
51059 {
51060 arg3 = &temp3;
51061 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51062 }
51063 {
51064 PyThreadState* __tstate = wxPyBeginAllowThreads();
51065 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
51066 wxPyEndAllowThreads(__tstate);
51067 if (PyErr_Occurred()) SWIG_fail;
51068 }
51069 {
51070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51071 }
51072 return resultobj;
51073 fail:
51074 return NULL;
51075 }
51076
51077
51078 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51079 PyObject *resultobj = 0;
51080 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51081 wxGBPosition result;
51082 void *argp1 = 0 ;
51083 int res1 = 0 ;
51084 PyObject *swig_obj[1] ;
51085
51086 if (!args) SWIG_fail;
51087 swig_obj[0] = args;
51088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51089 if (!SWIG_IsOK(res1)) {
51090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51091 }
51092 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51093 {
51094 PyThreadState* __tstate = wxPyBeginAllowThreads();
51095 result = wxGBSizerItem_GetEndPos(arg1);
51096 wxPyEndAllowThreads(__tstate);
51097 if (PyErr_Occurred()) SWIG_fail;
51098 }
51099 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51100 return resultobj;
51101 fail:
51102 return NULL;
51103 }
51104
51105
51106 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51107 PyObject *resultobj = 0;
51108 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51109 wxGridBagSizer *result = 0 ;
51110 void *argp1 = 0 ;
51111 int res1 = 0 ;
51112 PyObject *swig_obj[1] ;
51113
51114 if (!args) SWIG_fail;
51115 swig_obj[0] = args;
51116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51117 if (!SWIG_IsOK(res1)) {
51118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
51119 }
51120 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51121 {
51122 PyThreadState* __tstate = wxPyBeginAllowThreads();
51123 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
51124 wxPyEndAllowThreads(__tstate);
51125 if (PyErr_Occurred()) SWIG_fail;
51126 }
51127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51128 return resultobj;
51129 fail:
51130 return NULL;
51131 }
51132
51133
51134 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51135 PyObject *resultobj = 0;
51136 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
51137 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
51138 void *argp1 = 0 ;
51139 int res1 = 0 ;
51140 void *argp2 = 0 ;
51141 int res2 = 0 ;
51142 PyObject * obj0 = 0 ;
51143 PyObject * obj1 = 0 ;
51144 char * kwnames[] = {
51145 (char *) "self",(char *) "sizer", NULL
51146 };
51147
51148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51150 if (!SWIG_IsOK(res1)) {
51151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
51152 }
51153 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
51154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51155 if (!SWIG_IsOK(res2)) {
51156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
51157 }
51158 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
51159 {
51160 PyThreadState* __tstate = wxPyBeginAllowThreads();
51161 (arg1)->SetGBSizer(arg2);
51162 wxPyEndAllowThreads(__tstate);
51163 if (PyErr_Occurred()) SWIG_fail;
51164 }
51165 resultobj = SWIG_Py_Void();
51166 return resultobj;
51167 fail:
51168 return NULL;
51169 }
51170
51171
51172 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51173 PyObject *obj;
51174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51175 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
51176 return SWIG_Py_Void();
51177 }
51178
51179 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51180 return SWIG_Python_InitShadowInstance(args);
51181 }
51182
51183 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51184 PyObject *resultobj = 0;
51185 int arg1 = (int) 0 ;
51186 int arg2 = (int) 0 ;
51187 wxGridBagSizer *result = 0 ;
51188 int val1 ;
51189 int ecode1 = 0 ;
51190 int val2 ;
51191 int ecode2 = 0 ;
51192 PyObject * obj0 = 0 ;
51193 PyObject * obj1 = 0 ;
51194 char * kwnames[] = {
51195 (char *) "vgap",(char *) "hgap", NULL
51196 };
51197
51198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51199 if (obj0) {
51200 ecode1 = SWIG_AsVal_int(obj0, &val1);
51201 if (!SWIG_IsOK(ecode1)) {
51202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
51203 }
51204 arg1 = static_cast< int >(val1);
51205 }
51206 if (obj1) {
51207 ecode2 = SWIG_AsVal_int(obj1, &val2);
51208 if (!SWIG_IsOK(ecode2)) {
51209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
51210 }
51211 arg2 = static_cast< int >(val2);
51212 }
51213 {
51214 PyThreadState* __tstate = wxPyBeginAllowThreads();
51215 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
51216 wxPyEndAllowThreads(__tstate);
51217 if (PyErr_Occurred()) SWIG_fail;
51218 }
51219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
51220 return resultobj;
51221 fail:
51222 return NULL;
51223 }
51224
51225
51226 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51227 PyObject *resultobj = 0;
51228 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51229 PyObject *arg2 = (PyObject *) 0 ;
51230 wxGBPosition *arg3 = 0 ;
51231 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
51232 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
51233 int arg5 = (int) 0 ;
51234 int arg6 = (int) 0 ;
51235 PyObject *arg7 = (PyObject *) NULL ;
51236 wxGBSizerItem *result = 0 ;
51237 void *argp1 = 0 ;
51238 int res1 = 0 ;
51239 wxGBPosition temp3 ;
51240 wxGBSpan temp4 ;
51241 int val5 ;
51242 int ecode5 = 0 ;
51243 int val6 ;
51244 int ecode6 = 0 ;
51245 PyObject * obj0 = 0 ;
51246 PyObject * obj1 = 0 ;
51247 PyObject * obj2 = 0 ;
51248 PyObject * obj3 = 0 ;
51249 PyObject * obj4 = 0 ;
51250 PyObject * obj5 = 0 ;
51251 PyObject * obj6 = 0 ;
51252 char * kwnames[] = {
51253 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
51254 };
51255
51256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51258 if (!SWIG_IsOK(res1)) {
51259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51260 }
51261 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51262 arg2 = obj1;
51263 {
51264 arg3 = &temp3;
51265 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
51266 }
51267 if (obj3) {
51268 {
51269 arg4 = &temp4;
51270 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
51271 }
51272 }
51273 if (obj4) {
51274 ecode5 = SWIG_AsVal_int(obj4, &val5);
51275 if (!SWIG_IsOK(ecode5)) {
51276 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
51277 }
51278 arg5 = static_cast< int >(val5);
51279 }
51280 if (obj5) {
51281 ecode6 = SWIG_AsVal_int(obj5, &val6);
51282 if (!SWIG_IsOK(ecode6)) {
51283 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
51284 }
51285 arg6 = static_cast< int >(val6);
51286 }
51287 if (obj6) {
51288 arg7 = obj6;
51289 }
51290 {
51291 PyThreadState* __tstate = wxPyBeginAllowThreads();
51292 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
51293 wxPyEndAllowThreads(__tstate);
51294 if (PyErr_Occurred()) SWIG_fail;
51295 }
51296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51297 return resultobj;
51298 fail:
51299 return NULL;
51300 }
51301
51302
51303 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51304 PyObject *resultobj = 0;
51305 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51306 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51307 wxGBSizerItem *result = 0 ;
51308 void *argp1 = 0 ;
51309 int res1 = 0 ;
51310 int res2 = 0 ;
51311 PyObject * obj0 = 0 ;
51312 PyObject * obj1 = 0 ;
51313 char * kwnames[] = {
51314 (char *) "self",(char *) "item", NULL
51315 };
51316
51317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51319 if (!SWIG_IsOK(res1)) {
51320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51321 }
51322 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51323 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
51324 if (!SWIG_IsOK(res2)) {
51325 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51326 }
51327 {
51328 PyThreadState* __tstate = wxPyBeginAllowThreads();
51329 result = (wxGBSizerItem *)(arg1)->Add(arg2);
51330 wxPyEndAllowThreads(__tstate);
51331 if (PyErr_Occurred()) SWIG_fail;
51332 }
51333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51334 return resultobj;
51335 fail:
51336 return NULL;
51337 }
51338
51339
51340 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51341 PyObject *resultobj = 0;
51342 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51343 int arg2 ;
51344 int arg3 ;
51345 wxSize result;
51346 void *argp1 = 0 ;
51347 int res1 = 0 ;
51348 int val2 ;
51349 int ecode2 = 0 ;
51350 int val3 ;
51351 int ecode3 = 0 ;
51352 PyObject * obj0 = 0 ;
51353 PyObject * obj1 = 0 ;
51354 PyObject * obj2 = 0 ;
51355 char * kwnames[] = {
51356 (char *) "self",(char *) "row",(char *) "col", NULL
51357 };
51358
51359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51361 if (!SWIG_IsOK(res1)) {
51362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51363 }
51364 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51365 ecode2 = SWIG_AsVal_int(obj1, &val2);
51366 if (!SWIG_IsOK(ecode2)) {
51367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
51368 }
51369 arg2 = static_cast< int >(val2);
51370 ecode3 = SWIG_AsVal_int(obj2, &val3);
51371 if (!SWIG_IsOK(ecode3)) {
51372 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
51373 }
51374 arg3 = static_cast< int >(val3);
51375 {
51376 PyThreadState* __tstate = wxPyBeginAllowThreads();
51377 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
51378 wxPyEndAllowThreads(__tstate);
51379 if (PyErr_Occurred()) SWIG_fail;
51380 }
51381 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51382 return resultobj;
51383 fail:
51384 return NULL;
51385 }
51386
51387
51388 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51389 PyObject *resultobj = 0;
51390 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51391 wxSize result;
51392 void *argp1 = 0 ;
51393 int res1 = 0 ;
51394 PyObject *swig_obj[1] ;
51395
51396 if (!args) SWIG_fail;
51397 swig_obj[0] = args;
51398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51399 if (!SWIG_IsOK(res1)) {
51400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
51401 }
51402 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51403 {
51404 PyThreadState* __tstate = wxPyBeginAllowThreads();
51405 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
51406 wxPyEndAllowThreads(__tstate);
51407 if (PyErr_Occurred()) SWIG_fail;
51408 }
51409 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51410 return resultobj;
51411 fail:
51412 return NULL;
51413 }
51414
51415
51416 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51417 PyObject *resultobj = 0;
51418 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51419 wxSize *arg2 = 0 ;
51420 void *argp1 = 0 ;
51421 int res1 = 0 ;
51422 wxSize temp2 ;
51423 PyObject * obj0 = 0 ;
51424 PyObject * obj1 = 0 ;
51425 char * kwnames[] = {
51426 (char *) "self",(char *) "sz", NULL
51427 };
51428
51429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
51430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51431 if (!SWIG_IsOK(res1)) {
51432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51433 }
51434 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51435 {
51436 arg2 = &temp2;
51437 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51438 }
51439 {
51440 PyThreadState* __tstate = wxPyBeginAllowThreads();
51441 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
51442 wxPyEndAllowThreads(__tstate);
51443 if (PyErr_Occurred()) SWIG_fail;
51444 }
51445 resultobj = SWIG_Py_Void();
51446 return resultobj;
51447 fail:
51448 return NULL;
51449 }
51450
51451
51452 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51453 PyObject *resultobj = 0;
51454 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51455 wxWindow *arg2 = (wxWindow *) 0 ;
51456 wxGBPosition result;
51457 void *argp1 = 0 ;
51458 int res1 = 0 ;
51459 void *argp2 = 0 ;
51460 int res2 = 0 ;
51461
51462 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51464 if (!SWIG_IsOK(res1)) {
51465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51466 }
51467 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51468 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51469 if (!SWIG_IsOK(res2)) {
51470 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51471 }
51472 arg2 = reinterpret_cast< wxWindow * >(argp2);
51473 {
51474 PyThreadState* __tstate = wxPyBeginAllowThreads();
51475 result = (arg1)->GetItemPosition(arg2);
51476 wxPyEndAllowThreads(__tstate);
51477 if (PyErr_Occurred()) SWIG_fail;
51478 }
51479 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51480 return resultobj;
51481 fail:
51482 return NULL;
51483 }
51484
51485
51486 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51487 PyObject *resultobj = 0;
51488 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51489 wxSizer *arg2 = (wxSizer *) 0 ;
51490 wxGBPosition result;
51491 void *argp1 = 0 ;
51492 int res1 = 0 ;
51493 void *argp2 = 0 ;
51494 int res2 = 0 ;
51495
51496 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51498 if (!SWIG_IsOK(res1)) {
51499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51500 }
51501 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51502 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51503 if (!SWIG_IsOK(res2)) {
51504 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51505 }
51506 arg2 = reinterpret_cast< wxSizer * >(argp2);
51507 {
51508 PyThreadState* __tstate = wxPyBeginAllowThreads();
51509 result = (arg1)->GetItemPosition(arg2);
51510 wxPyEndAllowThreads(__tstate);
51511 if (PyErr_Occurred()) SWIG_fail;
51512 }
51513 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51514 return resultobj;
51515 fail:
51516 return NULL;
51517 }
51518
51519
51520 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51521 PyObject *resultobj = 0;
51522 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51523 size_t arg2 ;
51524 wxGBPosition result;
51525 void *argp1 = 0 ;
51526 int res1 = 0 ;
51527 size_t val2 ;
51528 int ecode2 = 0 ;
51529
51530 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51532 if (!SWIG_IsOK(res1)) {
51533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51534 }
51535 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51536 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51537 if (!SWIG_IsOK(ecode2)) {
51538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51539 }
51540 arg2 = static_cast< size_t >(val2);
51541 {
51542 PyThreadState* __tstate = wxPyBeginAllowThreads();
51543 result = (arg1)->GetItemPosition(arg2);
51544 wxPyEndAllowThreads(__tstate);
51545 if (PyErr_Occurred()) SWIG_fail;
51546 }
51547 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
51548 return resultobj;
51549 fail:
51550 return NULL;
51551 }
51552
51553
51554 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
51555 int argc;
51556 PyObject *argv[3];
51557
51558 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
51559 --argc;
51560 if (argc == 2) {
51561 int _v = 0;
51562 {
51563 void *vptr = 0;
51564 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51565 _v = SWIG_CheckState(res);
51566 }
51567 if (!_v) goto check_1;
51568 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
51569 }
51570 check_1:
51571
51572 if (argc == 2) {
51573 int _v = 0;
51574 {
51575 void *vptr = 0;
51576 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51577 _v = SWIG_CheckState(res);
51578 }
51579 if (!_v) goto check_2;
51580 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
51581 }
51582 check_2:
51583
51584 if (argc == 2) {
51585 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
51586 }
51587
51588 fail:
51589 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
51590 return NULL;
51591 }
51592
51593
51594 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51595 PyObject *resultobj = 0;
51596 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51597 wxWindow *arg2 = (wxWindow *) 0 ;
51598 wxGBPosition *arg3 = 0 ;
51599 bool result;
51600 void *argp1 = 0 ;
51601 int res1 = 0 ;
51602 void *argp2 = 0 ;
51603 int res2 = 0 ;
51604 wxGBPosition temp3 ;
51605
51606 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51608 if (!SWIG_IsOK(res1)) {
51609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51610 }
51611 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51612 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51613 if (!SWIG_IsOK(res2)) {
51614 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
51615 }
51616 arg2 = reinterpret_cast< wxWindow * >(argp2);
51617 {
51618 arg3 = &temp3;
51619 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51620 }
51621 {
51622 PyThreadState* __tstate = wxPyBeginAllowThreads();
51623 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51624 wxPyEndAllowThreads(__tstate);
51625 if (PyErr_Occurred()) SWIG_fail;
51626 }
51627 {
51628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51629 }
51630 return resultobj;
51631 fail:
51632 return NULL;
51633 }
51634
51635
51636 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51637 PyObject *resultobj = 0;
51638 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51639 wxSizer *arg2 = (wxSizer *) 0 ;
51640 wxGBPosition *arg3 = 0 ;
51641 bool result;
51642 void *argp1 = 0 ;
51643 int res1 = 0 ;
51644 void *argp2 = 0 ;
51645 int res2 = 0 ;
51646 wxGBPosition temp3 ;
51647
51648 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51650 if (!SWIG_IsOK(res1)) {
51651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51652 }
51653 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51654 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51655 if (!SWIG_IsOK(res2)) {
51656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
51657 }
51658 arg2 = reinterpret_cast< wxSizer * >(argp2);
51659 {
51660 arg3 = &temp3;
51661 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51662 }
51663 {
51664 PyThreadState* __tstate = wxPyBeginAllowThreads();
51665 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51666 wxPyEndAllowThreads(__tstate);
51667 if (PyErr_Occurred()) SWIG_fail;
51668 }
51669 {
51670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51671 }
51672 return resultobj;
51673 fail:
51674 return NULL;
51675 }
51676
51677
51678 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51679 PyObject *resultobj = 0;
51680 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51681 size_t arg2 ;
51682 wxGBPosition *arg3 = 0 ;
51683 bool result;
51684 void *argp1 = 0 ;
51685 int res1 = 0 ;
51686 size_t val2 ;
51687 int ecode2 = 0 ;
51688 wxGBPosition temp3 ;
51689
51690 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51692 if (!SWIG_IsOK(res1)) {
51693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51694 }
51695 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51696 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51697 if (!SWIG_IsOK(ecode2)) {
51698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
51699 }
51700 arg2 = static_cast< size_t >(val2);
51701 {
51702 arg3 = &temp3;
51703 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
51704 }
51705 {
51706 PyThreadState* __tstate = wxPyBeginAllowThreads();
51707 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
51708 wxPyEndAllowThreads(__tstate);
51709 if (PyErr_Occurred()) SWIG_fail;
51710 }
51711 {
51712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51713 }
51714 return resultobj;
51715 fail:
51716 return NULL;
51717 }
51718
51719
51720 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
51721 int argc;
51722 PyObject *argv[4];
51723
51724 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
51725 --argc;
51726 if (argc == 3) {
51727 int _v = 0;
51728 {
51729 void *vptr = 0;
51730 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51731 _v = SWIG_CheckState(res);
51732 }
51733 if (!_v) goto check_1;
51734 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
51735 }
51736 check_1:
51737
51738 if (argc == 3) {
51739 int _v = 0;
51740 {
51741 void *vptr = 0;
51742 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51743 _v = SWIG_CheckState(res);
51744 }
51745 if (!_v) goto check_2;
51746 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
51747 }
51748 check_2:
51749
51750 if (argc == 3) {
51751 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
51752 }
51753
51754 fail:
51755 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
51756 return NULL;
51757 }
51758
51759
51760 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51761 PyObject *resultobj = 0;
51762 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51763 wxWindow *arg2 = (wxWindow *) 0 ;
51764 wxGBSpan result;
51765 void *argp1 = 0 ;
51766 int res1 = 0 ;
51767 void *argp2 = 0 ;
51768 int res2 = 0 ;
51769
51770 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51772 if (!SWIG_IsOK(res1)) {
51773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51774 }
51775 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51776 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51777 if (!SWIG_IsOK(res2)) {
51778 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51779 }
51780 arg2 = reinterpret_cast< wxWindow * >(argp2);
51781 {
51782 PyThreadState* __tstate = wxPyBeginAllowThreads();
51783 result = (arg1)->GetItemSpan(arg2);
51784 wxPyEndAllowThreads(__tstate);
51785 if (PyErr_Occurred()) SWIG_fail;
51786 }
51787 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51788 return resultobj;
51789 fail:
51790 return NULL;
51791 }
51792
51793
51794 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51795 PyObject *resultobj = 0;
51796 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51797 wxSizer *arg2 = (wxSizer *) 0 ;
51798 wxGBSpan result;
51799 void *argp1 = 0 ;
51800 int res1 = 0 ;
51801 void *argp2 = 0 ;
51802 int res2 = 0 ;
51803
51804 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51806 if (!SWIG_IsOK(res1)) {
51807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51808 }
51809 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51810 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51811 if (!SWIG_IsOK(res2)) {
51812 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51813 }
51814 arg2 = reinterpret_cast< wxSizer * >(argp2);
51815 {
51816 PyThreadState* __tstate = wxPyBeginAllowThreads();
51817 result = (arg1)->GetItemSpan(arg2);
51818 wxPyEndAllowThreads(__tstate);
51819 if (PyErr_Occurred()) SWIG_fail;
51820 }
51821 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51822 return resultobj;
51823 fail:
51824 return NULL;
51825 }
51826
51827
51828 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51829 PyObject *resultobj = 0;
51830 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51831 size_t arg2 ;
51832 wxGBSpan result;
51833 void *argp1 = 0 ;
51834 int res1 = 0 ;
51835 size_t val2 ;
51836 int ecode2 = 0 ;
51837
51838 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51840 if (!SWIG_IsOK(res1)) {
51841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51842 }
51843 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51844 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51845 if (!SWIG_IsOK(ecode2)) {
51846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51847 }
51848 arg2 = static_cast< size_t >(val2);
51849 {
51850 PyThreadState* __tstate = wxPyBeginAllowThreads();
51851 result = (arg1)->GetItemSpan(arg2);
51852 wxPyEndAllowThreads(__tstate);
51853 if (PyErr_Occurred()) SWIG_fail;
51854 }
51855 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
51856 return resultobj;
51857 fail:
51858 return NULL;
51859 }
51860
51861
51862 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
51863 int argc;
51864 PyObject *argv[3];
51865
51866 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
51867 --argc;
51868 if (argc == 2) {
51869 int _v = 0;
51870 {
51871 void *vptr = 0;
51872 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51873 _v = SWIG_CheckState(res);
51874 }
51875 if (!_v) goto check_1;
51876 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
51877 }
51878 check_1:
51879
51880 if (argc == 2) {
51881 int _v = 0;
51882 {
51883 void *vptr = 0;
51884 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51885 _v = SWIG_CheckState(res);
51886 }
51887 if (!_v) goto check_2;
51888 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
51889 }
51890 check_2:
51891
51892 if (argc == 2) {
51893 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
51894 }
51895
51896 fail:
51897 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
51898 return NULL;
51899 }
51900
51901
51902 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51903 PyObject *resultobj = 0;
51904 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51905 wxWindow *arg2 = (wxWindow *) 0 ;
51906 wxGBSpan *arg3 = 0 ;
51907 bool result;
51908 void *argp1 = 0 ;
51909 int res1 = 0 ;
51910 void *argp2 = 0 ;
51911 int res2 = 0 ;
51912 wxGBSpan temp3 ;
51913
51914 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51916 if (!SWIG_IsOK(res1)) {
51917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51918 }
51919 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51920 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51921 if (!SWIG_IsOK(res2)) {
51922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
51923 }
51924 arg2 = reinterpret_cast< wxWindow * >(argp2);
51925 {
51926 arg3 = &temp3;
51927 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51928 }
51929 {
51930 PyThreadState* __tstate = wxPyBeginAllowThreads();
51931 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51932 wxPyEndAllowThreads(__tstate);
51933 if (PyErr_Occurred()) SWIG_fail;
51934 }
51935 {
51936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51937 }
51938 return resultobj;
51939 fail:
51940 return NULL;
51941 }
51942
51943
51944 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51945 PyObject *resultobj = 0;
51946 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51947 wxSizer *arg2 = (wxSizer *) 0 ;
51948 wxGBSpan *arg3 = 0 ;
51949 bool result;
51950 void *argp1 = 0 ;
51951 int res1 = 0 ;
51952 void *argp2 = 0 ;
51953 int res2 = 0 ;
51954 wxGBSpan temp3 ;
51955
51956 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51958 if (!SWIG_IsOK(res1)) {
51959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51960 }
51961 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51962 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51963 if (!SWIG_IsOK(res2)) {
51964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51965 }
51966 arg2 = reinterpret_cast< wxSizer * >(argp2);
51967 {
51968 arg3 = &temp3;
51969 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51970 }
51971 {
51972 PyThreadState* __tstate = wxPyBeginAllowThreads();
51973 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51974 wxPyEndAllowThreads(__tstate);
51975 if (PyErr_Occurred()) SWIG_fail;
51976 }
51977 {
51978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51979 }
51980 return resultobj;
51981 fail:
51982 return NULL;
51983 }
51984
51985
51986 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51987 PyObject *resultobj = 0;
51988 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51989 size_t arg2 ;
51990 wxGBSpan *arg3 = 0 ;
51991 bool result;
51992 void *argp1 = 0 ;
51993 int res1 = 0 ;
51994 size_t val2 ;
51995 int ecode2 = 0 ;
51996 wxGBSpan temp3 ;
51997
51998 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52000 if (!SWIG_IsOK(res1)) {
52001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52002 }
52003 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52004 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
52005 if (!SWIG_IsOK(ecode2)) {
52006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
52007 }
52008 arg2 = static_cast< size_t >(val2);
52009 {
52010 arg3 = &temp3;
52011 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
52012 }
52013 {
52014 PyThreadState* __tstate = wxPyBeginAllowThreads();
52015 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
52016 wxPyEndAllowThreads(__tstate);
52017 if (PyErr_Occurred()) SWIG_fail;
52018 }
52019 {
52020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52021 }
52022 return resultobj;
52023 fail:
52024 return NULL;
52025 }
52026
52027
52028 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
52029 int argc;
52030 PyObject *argv[4];
52031
52032 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
52033 --argc;
52034 if (argc == 3) {
52035 int _v = 0;
52036 {
52037 void *vptr = 0;
52038 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52039 _v = SWIG_CheckState(res);
52040 }
52041 if (!_v) goto check_1;
52042 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
52043 }
52044 check_1:
52045
52046 if (argc == 3) {
52047 int _v = 0;
52048 {
52049 void *vptr = 0;
52050 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
52051 _v = SWIG_CheckState(res);
52052 }
52053 if (!_v) goto check_2;
52054 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
52055 }
52056 check_2:
52057
52058 if (argc == 3) {
52059 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
52060 }
52061
52062 fail:
52063 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
52064 return NULL;
52065 }
52066
52067
52068 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52069 PyObject *resultobj = 0;
52070 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52071 wxWindow *arg2 = (wxWindow *) 0 ;
52072 wxGBSizerItem *result = 0 ;
52073 void *argp1 = 0 ;
52074 int res1 = 0 ;
52075 void *argp2 = 0 ;
52076 int res2 = 0 ;
52077
52078 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52080 if (!SWIG_IsOK(res1)) {
52081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52082 }
52083 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52084 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52085 if (!SWIG_IsOK(res2)) {
52086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
52087 }
52088 arg2 = reinterpret_cast< wxWindow * >(argp2);
52089 {
52090 PyThreadState* __tstate = wxPyBeginAllowThreads();
52091 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52092 wxPyEndAllowThreads(__tstate);
52093 if (PyErr_Occurred()) SWIG_fail;
52094 }
52095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52096 return resultobj;
52097 fail:
52098 return NULL;
52099 }
52100
52101
52102 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
52103 PyObject *resultobj = 0;
52104 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52105 wxSizer *arg2 = (wxSizer *) 0 ;
52106 wxGBSizerItem *result = 0 ;
52107 void *argp1 = 0 ;
52108 int res1 = 0 ;
52109 void *argp2 = 0 ;
52110 int res2 = 0 ;
52111
52112 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
52113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52114 if (!SWIG_IsOK(res1)) {
52115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52116 }
52117 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52118 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52119 if (!SWIG_IsOK(res2)) {
52120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
52121 }
52122 arg2 = reinterpret_cast< wxSizer * >(argp2);
52123 {
52124 PyThreadState* __tstate = wxPyBeginAllowThreads();
52125 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
52126 wxPyEndAllowThreads(__tstate);
52127 if (PyErr_Occurred()) SWIG_fail;
52128 }
52129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52130 return resultobj;
52131 fail:
52132 return NULL;
52133 }
52134
52135
52136 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
52137 int argc;
52138 PyObject *argv[3];
52139
52140 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
52141 --argc;
52142 if (argc == 2) {
52143 int _v = 0;
52144 {
52145 void *vptr = 0;
52146 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
52147 _v = SWIG_CheckState(res);
52148 }
52149 if (!_v) goto check_1;
52150 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
52151 }
52152 check_1:
52153
52154 if (argc == 2) {
52155 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
52156 }
52157
52158 fail:
52159 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
52160 return NULL;
52161 }
52162
52163
52164 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52165 PyObject *resultobj = 0;
52166 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52167 wxGBPosition *arg2 = 0 ;
52168 wxGBSizerItem *result = 0 ;
52169 void *argp1 = 0 ;
52170 int res1 = 0 ;
52171 wxGBPosition temp2 ;
52172 PyObject * obj0 = 0 ;
52173 PyObject * obj1 = 0 ;
52174 char * kwnames[] = {
52175 (char *) "self",(char *) "pos", NULL
52176 };
52177
52178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52180 if (!SWIG_IsOK(res1)) {
52181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52182 }
52183 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52184 {
52185 arg2 = &temp2;
52186 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52187 }
52188 {
52189 PyThreadState* __tstate = wxPyBeginAllowThreads();
52190 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
52191 wxPyEndAllowThreads(__tstate);
52192 if (PyErr_Occurred()) SWIG_fail;
52193 }
52194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52195 return resultobj;
52196 fail:
52197 return NULL;
52198 }
52199
52200
52201 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52202 PyObject *resultobj = 0;
52203 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52204 wxPoint *arg2 = 0 ;
52205 wxGBSizerItem *result = 0 ;
52206 void *argp1 = 0 ;
52207 int res1 = 0 ;
52208 wxPoint temp2 ;
52209 PyObject * obj0 = 0 ;
52210 PyObject * obj1 = 0 ;
52211 char * kwnames[] = {
52212 (char *) "self",(char *) "pt", NULL
52213 };
52214
52215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
52216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52217 if (!SWIG_IsOK(res1)) {
52218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52219 }
52220 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52221 {
52222 arg2 = &temp2;
52223 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
52224 }
52225 {
52226 PyThreadState* __tstate = wxPyBeginAllowThreads();
52227 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
52228 wxPyEndAllowThreads(__tstate);
52229 if (PyErr_Occurred()) SWIG_fail;
52230 }
52231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52232 return resultobj;
52233 fail:
52234 return NULL;
52235 }
52236
52237
52238 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52239 PyObject *resultobj = 0;
52240 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52241 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
52242 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
52243 bool result;
52244 void *argp1 = 0 ;
52245 int res1 = 0 ;
52246 void *argp2 = 0 ;
52247 int res2 = 0 ;
52248 void *argp3 = 0 ;
52249 int res3 = 0 ;
52250 PyObject * obj0 = 0 ;
52251 PyObject * obj1 = 0 ;
52252 PyObject * obj2 = 0 ;
52253 char * kwnames[] = {
52254 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
52255 };
52256
52257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52259 if (!SWIG_IsOK(res1)) {
52260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52261 }
52262 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52263 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52264 if (!SWIG_IsOK(res2)) {
52265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
52266 }
52267 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
52268 if (obj2) {
52269 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52270 if (!SWIG_IsOK(res3)) {
52271 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
52272 }
52273 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
52274 }
52275 {
52276 PyThreadState* __tstate = wxPyBeginAllowThreads();
52277 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
52278 wxPyEndAllowThreads(__tstate);
52279 if (PyErr_Occurred()) SWIG_fail;
52280 }
52281 {
52282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52283 }
52284 return resultobj;
52285 fail:
52286 return NULL;
52287 }
52288
52289
52290 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52291 PyObject *resultobj = 0;
52292 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
52293 wxGBPosition *arg2 = 0 ;
52294 wxGBSpan *arg3 = 0 ;
52295 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
52296 bool result;
52297 void *argp1 = 0 ;
52298 int res1 = 0 ;
52299 wxGBPosition temp2 ;
52300 wxGBSpan temp3 ;
52301 void *argp4 = 0 ;
52302 int res4 = 0 ;
52303 PyObject * obj0 = 0 ;
52304 PyObject * obj1 = 0 ;
52305 PyObject * obj2 = 0 ;
52306 PyObject * obj3 = 0 ;
52307 char * kwnames[] = {
52308 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
52309 };
52310
52311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
52313 if (!SWIG_IsOK(res1)) {
52314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
52315 }
52316 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
52317 {
52318 arg2 = &temp2;
52319 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
52320 }
52321 {
52322 arg3 = &temp3;
52323 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
52324 }
52325 if (obj3) {
52326 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
52327 if (!SWIG_IsOK(res4)) {
52328 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
52329 }
52330 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
52331 }
52332 {
52333 PyThreadState* __tstate = wxPyBeginAllowThreads();
52334 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
52335 wxPyEndAllowThreads(__tstate);
52336 if (PyErr_Occurred()) SWIG_fail;
52337 }
52338 {
52339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52340 }
52341 return resultobj;
52342 fail:
52343 return NULL;
52344 }
52345
52346
52347 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52348 PyObject *obj;
52349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52350 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
52351 return SWIG_Py_Void();
52352 }
52353
52354 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52355 return SWIG_Python_InitShadowInstance(args);
52356 }
52357
52358 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52359 PyObject *resultobj = 0;
52360 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52361 wxRelationship arg2 ;
52362 wxWindow *arg3 = (wxWindow *) 0 ;
52363 wxEdge arg4 ;
52364 int arg5 = (int) 0 ;
52365 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
52366 void *argp1 = 0 ;
52367 int res1 = 0 ;
52368 int val2 ;
52369 int ecode2 = 0 ;
52370 void *argp3 = 0 ;
52371 int res3 = 0 ;
52372 int val4 ;
52373 int ecode4 = 0 ;
52374 int val5 ;
52375 int ecode5 = 0 ;
52376 int val6 ;
52377 int ecode6 = 0 ;
52378 PyObject * obj0 = 0 ;
52379 PyObject * obj1 = 0 ;
52380 PyObject * obj2 = 0 ;
52381 PyObject * obj3 = 0 ;
52382 PyObject * obj4 = 0 ;
52383 PyObject * obj5 = 0 ;
52384 char * kwnames[] = {
52385 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
52386 };
52387
52388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
52389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52390 if (!SWIG_IsOK(res1)) {
52391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52392 }
52393 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52394 ecode2 = SWIG_AsVal_int(obj1, &val2);
52395 if (!SWIG_IsOK(ecode2)) {
52396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
52397 }
52398 arg2 = static_cast< wxRelationship >(val2);
52399 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52400 if (!SWIG_IsOK(res3)) {
52401 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
52402 }
52403 arg3 = reinterpret_cast< wxWindow * >(argp3);
52404 ecode4 = SWIG_AsVal_int(obj3, &val4);
52405 if (!SWIG_IsOK(ecode4)) {
52406 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
52407 }
52408 arg4 = static_cast< wxEdge >(val4);
52409 if (obj4) {
52410 ecode5 = SWIG_AsVal_int(obj4, &val5);
52411 if (!SWIG_IsOK(ecode5)) {
52412 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
52413 }
52414 arg5 = static_cast< int >(val5);
52415 }
52416 if (obj5) {
52417 ecode6 = SWIG_AsVal_int(obj5, &val6);
52418 if (!SWIG_IsOK(ecode6)) {
52419 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
52420 }
52421 arg6 = static_cast< int >(val6);
52422 }
52423 {
52424 PyThreadState* __tstate = wxPyBeginAllowThreads();
52425 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
52426 wxPyEndAllowThreads(__tstate);
52427 if (PyErr_Occurred()) SWIG_fail;
52428 }
52429 resultobj = SWIG_Py_Void();
52430 return resultobj;
52431 fail:
52432 return NULL;
52433 }
52434
52435
52436 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52437 PyObject *resultobj = 0;
52438 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52439 wxWindow *arg2 = (wxWindow *) 0 ;
52440 int arg3 = (int) 0 ;
52441 void *argp1 = 0 ;
52442 int res1 = 0 ;
52443 void *argp2 = 0 ;
52444 int res2 = 0 ;
52445 int val3 ;
52446 int ecode3 = 0 ;
52447 PyObject * obj0 = 0 ;
52448 PyObject * obj1 = 0 ;
52449 PyObject * obj2 = 0 ;
52450 char * kwnames[] = {
52451 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52452 };
52453
52454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52456 if (!SWIG_IsOK(res1)) {
52457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52458 }
52459 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52460 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52461 if (!SWIG_IsOK(res2)) {
52462 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52463 }
52464 arg2 = reinterpret_cast< wxWindow * >(argp2);
52465 if (obj2) {
52466 ecode3 = SWIG_AsVal_int(obj2, &val3);
52467 if (!SWIG_IsOK(ecode3)) {
52468 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
52469 }
52470 arg3 = static_cast< int >(val3);
52471 }
52472 {
52473 PyThreadState* __tstate = wxPyBeginAllowThreads();
52474 (arg1)->LeftOf(arg2,arg3);
52475 wxPyEndAllowThreads(__tstate);
52476 if (PyErr_Occurred()) SWIG_fail;
52477 }
52478 resultobj = SWIG_Py_Void();
52479 return resultobj;
52480 fail:
52481 return NULL;
52482 }
52483
52484
52485 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52486 PyObject *resultobj = 0;
52487 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52488 wxWindow *arg2 = (wxWindow *) 0 ;
52489 int arg3 = (int) 0 ;
52490 void *argp1 = 0 ;
52491 int res1 = 0 ;
52492 void *argp2 = 0 ;
52493 int res2 = 0 ;
52494 int val3 ;
52495 int ecode3 = 0 ;
52496 PyObject * obj0 = 0 ;
52497 PyObject * obj1 = 0 ;
52498 PyObject * obj2 = 0 ;
52499 char * kwnames[] = {
52500 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52501 };
52502
52503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52505 if (!SWIG_IsOK(res1)) {
52506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52507 }
52508 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52510 if (!SWIG_IsOK(res2)) {
52511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52512 }
52513 arg2 = reinterpret_cast< wxWindow * >(argp2);
52514 if (obj2) {
52515 ecode3 = SWIG_AsVal_int(obj2, &val3);
52516 if (!SWIG_IsOK(ecode3)) {
52517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
52518 }
52519 arg3 = static_cast< int >(val3);
52520 }
52521 {
52522 PyThreadState* __tstate = wxPyBeginAllowThreads();
52523 (arg1)->RightOf(arg2,arg3);
52524 wxPyEndAllowThreads(__tstate);
52525 if (PyErr_Occurred()) SWIG_fail;
52526 }
52527 resultobj = SWIG_Py_Void();
52528 return resultobj;
52529 fail:
52530 return NULL;
52531 }
52532
52533
52534 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52535 PyObject *resultobj = 0;
52536 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52537 wxWindow *arg2 = (wxWindow *) 0 ;
52538 int arg3 = (int) 0 ;
52539 void *argp1 = 0 ;
52540 int res1 = 0 ;
52541 void *argp2 = 0 ;
52542 int res2 = 0 ;
52543 int val3 ;
52544 int ecode3 = 0 ;
52545 PyObject * obj0 = 0 ;
52546 PyObject * obj1 = 0 ;
52547 PyObject * obj2 = 0 ;
52548 char * kwnames[] = {
52549 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52550 };
52551
52552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52554 if (!SWIG_IsOK(res1)) {
52555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52556 }
52557 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52558 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52559 if (!SWIG_IsOK(res2)) {
52560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
52561 }
52562 arg2 = reinterpret_cast< wxWindow * >(argp2);
52563 if (obj2) {
52564 ecode3 = SWIG_AsVal_int(obj2, &val3);
52565 if (!SWIG_IsOK(ecode3)) {
52566 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
52567 }
52568 arg3 = static_cast< int >(val3);
52569 }
52570 {
52571 PyThreadState* __tstate = wxPyBeginAllowThreads();
52572 (arg1)->Above(arg2,arg3);
52573 wxPyEndAllowThreads(__tstate);
52574 if (PyErr_Occurred()) SWIG_fail;
52575 }
52576 resultobj = SWIG_Py_Void();
52577 return resultobj;
52578 fail:
52579 return NULL;
52580 }
52581
52582
52583 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52584 PyObject *resultobj = 0;
52585 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52586 wxWindow *arg2 = (wxWindow *) 0 ;
52587 int arg3 = (int) 0 ;
52588 void *argp1 = 0 ;
52589 int res1 = 0 ;
52590 void *argp2 = 0 ;
52591 int res2 = 0 ;
52592 int val3 ;
52593 int ecode3 = 0 ;
52594 PyObject * obj0 = 0 ;
52595 PyObject * obj1 = 0 ;
52596 PyObject * obj2 = 0 ;
52597 char * kwnames[] = {
52598 (char *) "self",(char *) "sibling",(char *) "marg", NULL
52599 };
52600
52601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52603 if (!SWIG_IsOK(res1)) {
52604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52605 }
52606 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52608 if (!SWIG_IsOK(res2)) {
52609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
52610 }
52611 arg2 = reinterpret_cast< wxWindow * >(argp2);
52612 if (obj2) {
52613 ecode3 = SWIG_AsVal_int(obj2, &val3);
52614 if (!SWIG_IsOK(ecode3)) {
52615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
52616 }
52617 arg3 = static_cast< int >(val3);
52618 }
52619 {
52620 PyThreadState* __tstate = wxPyBeginAllowThreads();
52621 (arg1)->Below(arg2,arg3);
52622 wxPyEndAllowThreads(__tstate);
52623 if (PyErr_Occurred()) SWIG_fail;
52624 }
52625 resultobj = SWIG_Py_Void();
52626 return resultobj;
52627 fail:
52628 return NULL;
52629 }
52630
52631
52632 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52633 PyObject *resultobj = 0;
52634 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52635 wxWindow *arg2 = (wxWindow *) 0 ;
52636 wxEdge arg3 ;
52637 int arg4 = (int) 0 ;
52638 void *argp1 = 0 ;
52639 int res1 = 0 ;
52640 void *argp2 = 0 ;
52641 int res2 = 0 ;
52642 int val3 ;
52643 int ecode3 = 0 ;
52644 int val4 ;
52645 int ecode4 = 0 ;
52646 PyObject * obj0 = 0 ;
52647 PyObject * obj1 = 0 ;
52648 PyObject * obj2 = 0 ;
52649 PyObject * obj3 = 0 ;
52650 char * kwnames[] = {
52651 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
52652 };
52653
52654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52656 if (!SWIG_IsOK(res1)) {
52657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52658 }
52659 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52660 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52661 if (!SWIG_IsOK(res2)) {
52662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
52663 }
52664 arg2 = reinterpret_cast< wxWindow * >(argp2);
52665 ecode3 = SWIG_AsVal_int(obj2, &val3);
52666 if (!SWIG_IsOK(ecode3)) {
52667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
52668 }
52669 arg3 = static_cast< wxEdge >(val3);
52670 if (obj3) {
52671 ecode4 = SWIG_AsVal_int(obj3, &val4);
52672 if (!SWIG_IsOK(ecode4)) {
52673 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
52674 }
52675 arg4 = static_cast< int >(val4);
52676 }
52677 {
52678 PyThreadState* __tstate = wxPyBeginAllowThreads();
52679 (arg1)->SameAs(arg2,arg3,arg4);
52680 wxPyEndAllowThreads(__tstate);
52681 if (PyErr_Occurred()) SWIG_fail;
52682 }
52683 resultobj = SWIG_Py_Void();
52684 return resultobj;
52685 fail:
52686 return NULL;
52687 }
52688
52689
52690 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52691 PyObject *resultobj = 0;
52692 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52693 wxWindow *arg2 = (wxWindow *) 0 ;
52694 wxEdge arg3 ;
52695 int arg4 ;
52696 void *argp1 = 0 ;
52697 int res1 = 0 ;
52698 void *argp2 = 0 ;
52699 int res2 = 0 ;
52700 int val3 ;
52701 int ecode3 = 0 ;
52702 int val4 ;
52703 int ecode4 = 0 ;
52704 PyObject * obj0 = 0 ;
52705 PyObject * obj1 = 0 ;
52706 PyObject * obj2 = 0 ;
52707 PyObject * obj3 = 0 ;
52708 char * kwnames[] = {
52709 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
52710 };
52711
52712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52714 if (!SWIG_IsOK(res1)) {
52715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52716 }
52717 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52718 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52719 if (!SWIG_IsOK(res2)) {
52720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
52721 }
52722 arg2 = reinterpret_cast< wxWindow * >(argp2);
52723 ecode3 = SWIG_AsVal_int(obj2, &val3);
52724 if (!SWIG_IsOK(ecode3)) {
52725 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
52726 }
52727 arg3 = static_cast< wxEdge >(val3);
52728 ecode4 = SWIG_AsVal_int(obj3, &val4);
52729 if (!SWIG_IsOK(ecode4)) {
52730 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
52731 }
52732 arg4 = static_cast< int >(val4);
52733 {
52734 PyThreadState* __tstate = wxPyBeginAllowThreads();
52735 (arg1)->PercentOf(arg2,arg3,arg4);
52736 wxPyEndAllowThreads(__tstate);
52737 if (PyErr_Occurred()) SWIG_fail;
52738 }
52739 resultobj = SWIG_Py_Void();
52740 return resultobj;
52741 fail:
52742 return NULL;
52743 }
52744
52745
52746 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52747 PyObject *resultobj = 0;
52748 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52749 int arg2 ;
52750 void *argp1 = 0 ;
52751 int res1 = 0 ;
52752 int val2 ;
52753 int ecode2 = 0 ;
52754 PyObject * obj0 = 0 ;
52755 PyObject * obj1 = 0 ;
52756 char * kwnames[] = {
52757 (char *) "self",(char *) "val", NULL
52758 };
52759
52760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
52761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52762 if (!SWIG_IsOK(res1)) {
52763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52764 }
52765 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52766 ecode2 = SWIG_AsVal_int(obj1, &val2);
52767 if (!SWIG_IsOK(ecode2)) {
52768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
52769 }
52770 arg2 = static_cast< int >(val2);
52771 {
52772 PyThreadState* __tstate = wxPyBeginAllowThreads();
52773 (arg1)->Absolute(arg2);
52774 wxPyEndAllowThreads(__tstate);
52775 if (PyErr_Occurred()) SWIG_fail;
52776 }
52777 resultobj = SWIG_Py_Void();
52778 return resultobj;
52779 fail:
52780 return NULL;
52781 }
52782
52783
52784 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52785 PyObject *resultobj = 0;
52786 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52787 void *argp1 = 0 ;
52788 int res1 = 0 ;
52789 PyObject *swig_obj[1] ;
52790
52791 if (!args) SWIG_fail;
52792 swig_obj[0] = args;
52793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52794 if (!SWIG_IsOK(res1)) {
52795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52796 }
52797 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52798 {
52799 PyThreadState* __tstate = wxPyBeginAllowThreads();
52800 (arg1)->Unconstrained();
52801 wxPyEndAllowThreads(__tstate);
52802 if (PyErr_Occurred()) SWIG_fail;
52803 }
52804 resultobj = SWIG_Py_Void();
52805 return resultobj;
52806 fail:
52807 return NULL;
52808 }
52809
52810
52811 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52812 PyObject *resultobj = 0;
52813 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52814 void *argp1 = 0 ;
52815 int res1 = 0 ;
52816 PyObject *swig_obj[1] ;
52817
52818 if (!args) SWIG_fail;
52819 swig_obj[0] = args;
52820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52821 if (!SWIG_IsOK(res1)) {
52822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52823 }
52824 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52825 {
52826 PyThreadState* __tstate = wxPyBeginAllowThreads();
52827 (arg1)->AsIs();
52828 wxPyEndAllowThreads(__tstate);
52829 if (PyErr_Occurred()) SWIG_fail;
52830 }
52831 resultobj = SWIG_Py_Void();
52832 return resultobj;
52833 fail:
52834 return NULL;
52835 }
52836
52837
52838 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52839 PyObject *resultobj = 0;
52840 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52841 wxWindow *result = 0 ;
52842 void *argp1 = 0 ;
52843 int res1 = 0 ;
52844 PyObject *swig_obj[1] ;
52845
52846 if (!args) SWIG_fail;
52847 swig_obj[0] = args;
52848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52849 if (!SWIG_IsOK(res1)) {
52850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52851 }
52852 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52853 {
52854 PyThreadState* __tstate = wxPyBeginAllowThreads();
52855 result = (wxWindow *)(arg1)->GetOtherWindow();
52856 wxPyEndAllowThreads(__tstate);
52857 if (PyErr_Occurred()) SWIG_fail;
52858 }
52859 {
52860 resultobj = wxPyMake_wxObject(result, 0);
52861 }
52862 return resultobj;
52863 fail:
52864 return NULL;
52865 }
52866
52867
52868 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52869 PyObject *resultobj = 0;
52870 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52871 wxEdge result;
52872 void *argp1 = 0 ;
52873 int res1 = 0 ;
52874 PyObject *swig_obj[1] ;
52875
52876 if (!args) SWIG_fail;
52877 swig_obj[0] = args;
52878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52879 if (!SWIG_IsOK(res1)) {
52880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52881 }
52882 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52883 {
52884 PyThreadState* __tstate = wxPyBeginAllowThreads();
52885 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
52886 wxPyEndAllowThreads(__tstate);
52887 if (PyErr_Occurred()) SWIG_fail;
52888 }
52889 resultobj = SWIG_From_int(static_cast< int >(result));
52890 return resultobj;
52891 fail:
52892 return NULL;
52893 }
52894
52895
52896 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52897 PyObject *resultobj = 0;
52898 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52899 wxEdge arg2 ;
52900 void *argp1 = 0 ;
52901 int res1 = 0 ;
52902 int val2 ;
52903 int ecode2 = 0 ;
52904 PyObject * obj0 = 0 ;
52905 PyObject * obj1 = 0 ;
52906 char * kwnames[] = {
52907 (char *) "self",(char *) "which", NULL
52908 };
52909
52910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
52911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52912 if (!SWIG_IsOK(res1)) {
52913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52914 }
52915 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52916 ecode2 = SWIG_AsVal_int(obj1, &val2);
52917 if (!SWIG_IsOK(ecode2)) {
52918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52919 }
52920 arg2 = static_cast< wxEdge >(val2);
52921 {
52922 PyThreadState* __tstate = wxPyBeginAllowThreads();
52923 (arg1)->SetEdge(arg2);
52924 wxPyEndAllowThreads(__tstate);
52925 if (PyErr_Occurred()) SWIG_fail;
52926 }
52927 resultobj = SWIG_Py_Void();
52928 return resultobj;
52929 fail:
52930 return NULL;
52931 }
52932
52933
52934 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52935 PyObject *resultobj = 0;
52936 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52937 int arg2 ;
52938 void *argp1 = 0 ;
52939 int res1 = 0 ;
52940 int val2 ;
52941 int ecode2 = 0 ;
52942 PyObject * obj0 = 0 ;
52943 PyObject * obj1 = 0 ;
52944 char * kwnames[] = {
52945 (char *) "self",(char *) "v", NULL
52946 };
52947
52948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52950 if (!SWIG_IsOK(res1)) {
52951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52952 }
52953 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52954 ecode2 = SWIG_AsVal_int(obj1, &val2);
52955 if (!SWIG_IsOK(ecode2)) {
52956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52957 }
52958 arg2 = static_cast< int >(val2);
52959 {
52960 PyThreadState* __tstate = wxPyBeginAllowThreads();
52961 (arg1)->SetValue(arg2);
52962 wxPyEndAllowThreads(__tstate);
52963 if (PyErr_Occurred()) SWIG_fail;
52964 }
52965 resultobj = SWIG_Py_Void();
52966 return resultobj;
52967 fail:
52968 return NULL;
52969 }
52970
52971
52972 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52973 PyObject *resultobj = 0;
52974 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52975 int result;
52976 void *argp1 = 0 ;
52977 int res1 = 0 ;
52978 PyObject *swig_obj[1] ;
52979
52980 if (!args) SWIG_fail;
52981 swig_obj[0] = args;
52982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52983 if (!SWIG_IsOK(res1)) {
52984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52985 }
52986 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52987 {
52988 PyThreadState* __tstate = wxPyBeginAllowThreads();
52989 result = (int)(arg1)->GetMargin();
52990 wxPyEndAllowThreads(__tstate);
52991 if (PyErr_Occurred()) SWIG_fail;
52992 }
52993 resultobj = SWIG_From_int(static_cast< int >(result));
52994 return resultobj;
52995 fail:
52996 return NULL;
52997 }
52998
52999
53000 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53001 PyObject *resultobj = 0;
53002 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53003 int arg2 ;
53004 void *argp1 = 0 ;
53005 int res1 = 0 ;
53006 int val2 ;
53007 int ecode2 = 0 ;
53008 PyObject * obj0 = 0 ;
53009 PyObject * obj1 = 0 ;
53010 char * kwnames[] = {
53011 (char *) "self",(char *) "m", NULL
53012 };
53013
53014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
53015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53016 if (!SWIG_IsOK(res1)) {
53017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53018 }
53019 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53020 ecode2 = SWIG_AsVal_int(obj1, &val2);
53021 if (!SWIG_IsOK(ecode2)) {
53022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
53023 }
53024 arg2 = static_cast< int >(val2);
53025 {
53026 PyThreadState* __tstate = wxPyBeginAllowThreads();
53027 (arg1)->SetMargin(arg2);
53028 wxPyEndAllowThreads(__tstate);
53029 if (PyErr_Occurred()) SWIG_fail;
53030 }
53031 resultobj = SWIG_Py_Void();
53032 return resultobj;
53033 fail:
53034 return NULL;
53035 }
53036
53037
53038 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53039 PyObject *resultobj = 0;
53040 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53041 int result;
53042 void *argp1 = 0 ;
53043 int res1 = 0 ;
53044 PyObject *swig_obj[1] ;
53045
53046 if (!args) SWIG_fail;
53047 swig_obj[0] = args;
53048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53049 if (!SWIG_IsOK(res1)) {
53050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53051 }
53052 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53053 {
53054 PyThreadState* __tstate = wxPyBeginAllowThreads();
53055 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
53056 wxPyEndAllowThreads(__tstate);
53057 if (PyErr_Occurred()) SWIG_fail;
53058 }
53059 resultobj = SWIG_From_int(static_cast< int >(result));
53060 return resultobj;
53061 fail:
53062 return NULL;
53063 }
53064
53065
53066 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53067 PyObject *resultobj = 0;
53068 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53069 int result;
53070 void *argp1 = 0 ;
53071 int res1 = 0 ;
53072 PyObject *swig_obj[1] ;
53073
53074 if (!args) SWIG_fail;
53075 swig_obj[0] = args;
53076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53077 if (!SWIG_IsOK(res1)) {
53078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53079 }
53080 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53081 {
53082 PyThreadState* __tstate = wxPyBeginAllowThreads();
53083 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
53084 wxPyEndAllowThreads(__tstate);
53085 if (PyErr_Occurred()) SWIG_fail;
53086 }
53087 resultobj = SWIG_From_int(static_cast< int >(result));
53088 return resultobj;
53089 fail:
53090 return NULL;
53091 }
53092
53093
53094 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53095 PyObject *resultobj = 0;
53096 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53097 int result;
53098 void *argp1 = 0 ;
53099 int res1 = 0 ;
53100 PyObject *swig_obj[1] ;
53101
53102 if (!args) SWIG_fail;
53103 swig_obj[0] = args;
53104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53105 if (!SWIG_IsOK(res1)) {
53106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53107 }
53108 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53109 {
53110 PyThreadState* __tstate = wxPyBeginAllowThreads();
53111 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
53112 wxPyEndAllowThreads(__tstate);
53113 if (PyErr_Occurred()) SWIG_fail;
53114 }
53115 resultobj = SWIG_From_int(static_cast< int >(result));
53116 return resultobj;
53117 fail:
53118 return NULL;
53119 }
53120
53121
53122 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53123 PyObject *resultobj = 0;
53124 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53125 bool result;
53126 void *argp1 = 0 ;
53127 int res1 = 0 ;
53128 PyObject *swig_obj[1] ;
53129
53130 if (!args) SWIG_fail;
53131 swig_obj[0] = args;
53132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53133 if (!SWIG_IsOK(res1)) {
53134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53135 }
53136 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53137 {
53138 PyThreadState* __tstate = wxPyBeginAllowThreads();
53139 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
53140 wxPyEndAllowThreads(__tstate);
53141 if (PyErr_Occurred()) SWIG_fail;
53142 }
53143 {
53144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53145 }
53146 return resultobj;
53147 fail:
53148 return NULL;
53149 }
53150
53151
53152 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53153 PyObject *resultobj = 0;
53154 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53155 bool arg2 ;
53156 void *argp1 = 0 ;
53157 int res1 = 0 ;
53158 bool val2 ;
53159 int ecode2 = 0 ;
53160 PyObject * obj0 = 0 ;
53161 PyObject * obj1 = 0 ;
53162 char * kwnames[] = {
53163 (char *) "self",(char *) "d", NULL
53164 };
53165
53166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
53167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53168 if (!SWIG_IsOK(res1)) {
53169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53170 }
53171 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53172 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53173 if (!SWIG_IsOK(ecode2)) {
53174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
53175 }
53176 arg2 = static_cast< bool >(val2);
53177 {
53178 PyThreadState* __tstate = wxPyBeginAllowThreads();
53179 (arg1)->SetDone(arg2);
53180 wxPyEndAllowThreads(__tstate);
53181 if (PyErr_Occurred()) SWIG_fail;
53182 }
53183 resultobj = SWIG_Py_Void();
53184 return resultobj;
53185 fail:
53186 return NULL;
53187 }
53188
53189
53190 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53191 PyObject *resultobj = 0;
53192 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53193 wxRelationship result;
53194 void *argp1 = 0 ;
53195 int res1 = 0 ;
53196 PyObject *swig_obj[1] ;
53197
53198 if (!args) SWIG_fail;
53199 swig_obj[0] = args;
53200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53201 if (!SWIG_IsOK(res1)) {
53202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53203 }
53204 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53205 {
53206 PyThreadState* __tstate = wxPyBeginAllowThreads();
53207 result = (wxRelationship)(arg1)->GetRelationship();
53208 wxPyEndAllowThreads(__tstate);
53209 if (PyErr_Occurred()) SWIG_fail;
53210 }
53211 resultobj = SWIG_From_int(static_cast< int >(result));
53212 return resultobj;
53213 fail:
53214 return NULL;
53215 }
53216
53217
53218 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53219 PyObject *resultobj = 0;
53220 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53221 wxRelationship arg2 ;
53222 void *argp1 = 0 ;
53223 int res1 = 0 ;
53224 int val2 ;
53225 int ecode2 = 0 ;
53226 PyObject * obj0 = 0 ;
53227 PyObject * obj1 = 0 ;
53228 char * kwnames[] = {
53229 (char *) "self",(char *) "r", NULL
53230 };
53231
53232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
53233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53234 if (!SWIG_IsOK(res1)) {
53235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53236 }
53237 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53238 ecode2 = SWIG_AsVal_int(obj1, &val2);
53239 if (!SWIG_IsOK(ecode2)) {
53240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
53241 }
53242 arg2 = static_cast< wxRelationship >(val2);
53243 {
53244 PyThreadState* __tstate = wxPyBeginAllowThreads();
53245 (arg1)->SetRelationship(arg2);
53246 wxPyEndAllowThreads(__tstate);
53247 if (PyErr_Occurred()) SWIG_fail;
53248 }
53249 resultobj = SWIG_Py_Void();
53250 return resultobj;
53251 fail:
53252 return NULL;
53253 }
53254
53255
53256 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53257 PyObject *resultobj = 0;
53258 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53259 wxWindow *arg2 = (wxWindow *) 0 ;
53260 bool result;
53261 void *argp1 = 0 ;
53262 int res1 = 0 ;
53263 void *argp2 = 0 ;
53264 int res2 = 0 ;
53265 PyObject * obj0 = 0 ;
53266 PyObject * obj1 = 0 ;
53267 char * kwnames[] = {
53268 (char *) "self",(char *) "otherW", NULL
53269 };
53270
53271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
53272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53273 if (!SWIG_IsOK(res1)) {
53274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53275 }
53276 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53278 if (!SWIG_IsOK(res2)) {
53279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
53280 }
53281 arg2 = reinterpret_cast< wxWindow * >(argp2);
53282 {
53283 PyThreadState* __tstate = wxPyBeginAllowThreads();
53284 result = (bool)(arg1)->ResetIfWin(arg2);
53285 wxPyEndAllowThreads(__tstate);
53286 if (PyErr_Occurred()) SWIG_fail;
53287 }
53288 {
53289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53290 }
53291 return resultobj;
53292 fail:
53293 return NULL;
53294 }
53295
53296
53297 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53298 PyObject *resultobj = 0;
53299 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53300 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
53301 wxWindow *arg3 = (wxWindow *) 0 ;
53302 bool result;
53303 void *argp1 = 0 ;
53304 int res1 = 0 ;
53305 void *argp2 = 0 ;
53306 int res2 = 0 ;
53307 void *argp3 = 0 ;
53308 int res3 = 0 ;
53309 PyObject * obj0 = 0 ;
53310 PyObject * obj1 = 0 ;
53311 PyObject * obj2 = 0 ;
53312 char * kwnames[] = {
53313 (char *) "self",(char *) "constraints",(char *) "win", NULL
53314 };
53315
53316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53318 if (!SWIG_IsOK(res1)) {
53319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
53320 }
53321 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53323 if (!SWIG_IsOK(res2)) {
53324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
53325 }
53326 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
53327 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53328 if (!SWIG_IsOK(res3)) {
53329 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
53330 }
53331 arg3 = reinterpret_cast< wxWindow * >(argp3);
53332 {
53333 PyThreadState* __tstate = wxPyBeginAllowThreads();
53334 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
53335 wxPyEndAllowThreads(__tstate);
53336 if (PyErr_Occurred()) SWIG_fail;
53337 }
53338 {
53339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53340 }
53341 return resultobj;
53342 fail:
53343 return NULL;
53344 }
53345
53346
53347 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53348 PyObject *resultobj = 0;
53349 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
53350 wxEdge arg2 ;
53351 wxWindow *arg3 = (wxWindow *) 0 ;
53352 wxWindow *arg4 = (wxWindow *) 0 ;
53353 int result;
53354 void *argp1 = 0 ;
53355 int res1 = 0 ;
53356 int val2 ;
53357 int ecode2 = 0 ;
53358 void *argp3 = 0 ;
53359 int res3 = 0 ;
53360 void *argp4 = 0 ;
53361 int res4 = 0 ;
53362 PyObject * obj0 = 0 ;
53363 PyObject * obj1 = 0 ;
53364 PyObject * obj2 = 0 ;
53365 PyObject * obj3 = 0 ;
53366 char * kwnames[] = {
53367 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
53368 };
53369
53370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53372 if (!SWIG_IsOK(res1)) {
53373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
53374 }
53375 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
53376 ecode2 = SWIG_AsVal_int(obj1, &val2);
53377 if (!SWIG_IsOK(ecode2)) {
53378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
53379 }
53380 arg2 = static_cast< wxEdge >(val2);
53381 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
53382 if (!SWIG_IsOK(res3)) {
53383 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
53384 }
53385 arg3 = reinterpret_cast< wxWindow * >(argp3);
53386 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
53387 if (!SWIG_IsOK(res4)) {
53388 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
53389 }
53390 arg4 = reinterpret_cast< wxWindow * >(argp4);
53391 {
53392 PyThreadState* __tstate = wxPyBeginAllowThreads();
53393 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
53394 wxPyEndAllowThreads(__tstate);
53395 if (PyErr_Occurred()) SWIG_fail;
53396 }
53397 resultobj = SWIG_From_int(static_cast< int >(result));
53398 return resultobj;
53399 fail:
53400 return NULL;
53401 }
53402
53403
53404 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53405 PyObject *obj;
53406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53407 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
53408 return SWIG_Py_Void();
53409 }
53410
53411 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53412 PyObject *resultobj = 0;
53413 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53414 wxIndividualLayoutConstraint *result = 0 ;
53415 void *argp1 = 0 ;
53416 int res1 = 0 ;
53417 PyObject *swig_obj[1] ;
53418
53419 if (!args) SWIG_fail;
53420 swig_obj[0] = args;
53421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53422 if (!SWIG_IsOK(res1)) {
53423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53424 }
53425 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53426 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
53427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53428 return resultobj;
53429 fail:
53430 return NULL;
53431 }
53432
53433
53434 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53435 PyObject *resultobj = 0;
53436 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53437 wxIndividualLayoutConstraint *result = 0 ;
53438 void *argp1 = 0 ;
53439 int res1 = 0 ;
53440 PyObject *swig_obj[1] ;
53441
53442 if (!args) SWIG_fail;
53443 swig_obj[0] = args;
53444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53445 if (!SWIG_IsOK(res1)) {
53446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53447 }
53448 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53449 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
53450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53451 return resultobj;
53452 fail:
53453 return NULL;
53454 }
53455
53456
53457 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53458 PyObject *resultobj = 0;
53459 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53460 wxIndividualLayoutConstraint *result = 0 ;
53461 void *argp1 = 0 ;
53462 int res1 = 0 ;
53463 PyObject *swig_obj[1] ;
53464
53465 if (!args) SWIG_fail;
53466 swig_obj[0] = args;
53467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53468 if (!SWIG_IsOK(res1)) {
53469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53470 }
53471 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53472 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
53473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53474 return resultobj;
53475 fail:
53476 return NULL;
53477 }
53478
53479
53480 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53481 PyObject *resultobj = 0;
53482 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53483 wxIndividualLayoutConstraint *result = 0 ;
53484 void *argp1 = 0 ;
53485 int res1 = 0 ;
53486 PyObject *swig_obj[1] ;
53487
53488 if (!args) SWIG_fail;
53489 swig_obj[0] = args;
53490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53491 if (!SWIG_IsOK(res1)) {
53492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53493 }
53494 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53495 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
53496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53497 return resultobj;
53498 fail:
53499 return NULL;
53500 }
53501
53502
53503 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53504 PyObject *resultobj = 0;
53505 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53506 wxIndividualLayoutConstraint *result = 0 ;
53507 void *argp1 = 0 ;
53508 int res1 = 0 ;
53509 PyObject *swig_obj[1] ;
53510
53511 if (!args) SWIG_fail;
53512 swig_obj[0] = args;
53513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53514 if (!SWIG_IsOK(res1)) {
53515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53516 }
53517 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53518 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
53519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53520 return resultobj;
53521 fail:
53522 return NULL;
53523 }
53524
53525
53526 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53527 PyObject *resultobj = 0;
53528 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53529 wxIndividualLayoutConstraint *result = 0 ;
53530 void *argp1 = 0 ;
53531 int res1 = 0 ;
53532 PyObject *swig_obj[1] ;
53533
53534 if (!args) SWIG_fail;
53535 swig_obj[0] = args;
53536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53537 if (!SWIG_IsOK(res1)) {
53538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53539 }
53540 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53541 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
53542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53543 return resultobj;
53544 fail:
53545 return NULL;
53546 }
53547
53548
53549 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53550 PyObject *resultobj = 0;
53551 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53552 wxIndividualLayoutConstraint *result = 0 ;
53553 void *argp1 = 0 ;
53554 int res1 = 0 ;
53555 PyObject *swig_obj[1] ;
53556
53557 if (!args) SWIG_fail;
53558 swig_obj[0] = args;
53559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53560 if (!SWIG_IsOK(res1)) {
53561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53562 }
53563 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53564 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
53565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53566 return resultobj;
53567 fail:
53568 return NULL;
53569 }
53570
53571
53572 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53573 PyObject *resultobj = 0;
53574 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53575 wxIndividualLayoutConstraint *result = 0 ;
53576 void *argp1 = 0 ;
53577 int res1 = 0 ;
53578 PyObject *swig_obj[1] ;
53579
53580 if (!args) SWIG_fail;
53581 swig_obj[0] = args;
53582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53583 if (!SWIG_IsOK(res1)) {
53584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53585 }
53586 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53587 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
53588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
53589 return resultobj;
53590 fail:
53591 return NULL;
53592 }
53593
53594
53595 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53596 PyObject *resultobj = 0;
53597 wxLayoutConstraints *result = 0 ;
53598
53599 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
53600 {
53601 PyThreadState* __tstate = wxPyBeginAllowThreads();
53602 result = (wxLayoutConstraints *)new wxLayoutConstraints();
53603 wxPyEndAllowThreads(__tstate);
53604 if (PyErr_Occurred()) SWIG_fail;
53605 }
53606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
53607 return resultobj;
53608 fail:
53609 return NULL;
53610 }
53611
53612
53613 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53614 PyObject *resultobj = 0;
53615 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53616 void *argp1 = 0 ;
53617 int res1 = 0 ;
53618 PyObject *swig_obj[1] ;
53619
53620 if (!args) SWIG_fail;
53621 swig_obj[0] = args;
53622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
53623 if (!SWIG_IsOK(res1)) {
53624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53625 }
53626 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53627 {
53628 PyThreadState* __tstate = wxPyBeginAllowThreads();
53629 delete arg1;
53630
53631 wxPyEndAllowThreads(__tstate);
53632 if (PyErr_Occurred()) SWIG_fail;
53633 }
53634 resultobj = SWIG_Py_Void();
53635 return resultobj;
53636 fail:
53637 return NULL;
53638 }
53639
53640
53641 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53642 PyObject *resultobj = 0;
53643 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53644 wxWindow *arg2 = (wxWindow *) 0 ;
53645 int *arg3 = (int *) 0 ;
53646 bool result;
53647 void *argp1 = 0 ;
53648 int res1 = 0 ;
53649 void *argp2 = 0 ;
53650 int res2 = 0 ;
53651 int temp3 ;
53652 int res3 = SWIG_TMPOBJ ;
53653 PyObject * obj0 = 0 ;
53654 PyObject * obj1 = 0 ;
53655 char * kwnames[] = {
53656 (char *) "self",(char *) "win", NULL
53657 };
53658
53659 arg3 = &temp3;
53660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
53661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53662 if (!SWIG_IsOK(res1)) {
53663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
53664 }
53665 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53666 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
53667 if (!SWIG_IsOK(res2)) {
53668 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
53669 }
53670 arg2 = reinterpret_cast< wxWindow * >(argp2);
53671 {
53672 PyThreadState* __tstate = wxPyBeginAllowThreads();
53673 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
53674 wxPyEndAllowThreads(__tstate);
53675 if (PyErr_Occurred()) SWIG_fail;
53676 }
53677 {
53678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53679 }
53680 if (SWIG_IsTmpObj(res3)) {
53681 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
53682 } else {
53683 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
53684 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
53685 }
53686 return resultobj;
53687 fail:
53688 return NULL;
53689 }
53690
53691
53692 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53693 PyObject *resultobj = 0;
53694 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
53695 bool result;
53696 void *argp1 = 0 ;
53697 int res1 = 0 ;
53698 PyObject *swig_obj[1] ;
53699
53700 if (!args) SWIG_fail;
53701 swig_obj[0] = args;
53702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
53703 if (!SWIG_IsOK(res1)) {
53704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
53705 }
53706 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
53707 {
53708 PyThreadState* __tstate = wxPyBeginAllowThreads();
53709 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
53710 wxPyEndAllowThreads(__tstate);
53711 if (PyErr_Occurred()) SWIG_fail;
53712 }
53713 {
53714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53715 }
53716 return resultobj;
53717 fail:
53718 return NULL;
53719 }
53720
53721
53722 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53723 PyObject *obj;
53724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53725 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
53726 return SWIG_Py_Void();
53727 }
53728
53729 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53730 return SWIG_Python_InitShadowInstance(args);
53731 }
53732
53733 static PyMethodDef SwigMethods[] = {
53734 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
53735 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
53736 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
53737 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
53738 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
53739 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
53740 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
53741 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
53742 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
53744 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53752 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
53755 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
53756 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
53757 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
53759 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
53760 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
53761 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
53762 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
53763 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
53764 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
53765 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
53767 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53768 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53769 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
53773 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
53774 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
53775 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
53776 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
53777 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
53778 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
53779 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
53781 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
53789 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
53790 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
53791 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
53792 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
53794 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
53796 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
53797 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
53799 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
53801 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
53803 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
53804 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
53805 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
53807 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
53809 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
53810 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
53812 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
53814 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
53815 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
53816 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
53817 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
53818 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
53820 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
53832 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
53833 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
53837 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
53838 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
53839 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
53840 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
53841 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
53842 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
53843 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
53844 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
53846 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
53847 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
53848 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
53853 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
53854 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
53855 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
53856 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
53857 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
53863 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
53864 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53868 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
53870 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
53871 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
53872 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
53873 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53874 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
53875 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
53876 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
53877 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
53879 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
53880 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
53881 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
53882 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
53887 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
53888 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
53889 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
53890 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
53891 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
53892 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
53895 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
53896 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
53897 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
53899 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
53900 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
53902 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
53903 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
53904 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
53905 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
53906 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
53907 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
53908 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
53909 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
53910 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
53911 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
53912 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
53913 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
53918 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53920 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
53922 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
53924 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
53925 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
53926 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
53927 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
53929 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53930 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
53932 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53933 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53934 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
53935 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53938 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53939 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53940 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53943 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53944 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53945 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53949 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53950 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53951 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53955 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53957 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53958 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53960 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53961 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53962 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53963 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53964 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53965 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53966 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53967 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53973 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53974 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53976 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53977 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53978 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53984 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53985 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53986 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53987 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53988 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53989 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53990 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53991 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53992 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53993 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53994 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53995 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53996 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53997 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53998 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53999 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
54000 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
54001 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
54002 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
54003 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
54004 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
54005 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
54006 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
54008 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
54009 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54010 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54012 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
54014 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
54015 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
54017 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54019 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
54020 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54024 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
54026 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
54027 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54028 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
54029 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
54031 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
54035 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
54037 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54039 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
54040 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
54041 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
54042 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
54043 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
54044 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
54045 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
54046 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
54047 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
54048 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
54049 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
54050 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
54051 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
54052 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
54054 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
54056 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54057 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
54058 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
54059 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
54060 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
54061 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
54062 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
54063 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
54064 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
54065 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
54067 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54068 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
54070 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54072 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
54075 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
54076 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
54077 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54079 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54080 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
54081 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
54082 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
54088 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
54089 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
54091 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
54092 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
54093 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
54094 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
54095 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
54096 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
54097 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
54098 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
54099 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
54100 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
54101 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
54102 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
54103 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
54104 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
54105 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
54106 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
54107 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
54108 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
54109 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
54110 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
54111 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
54112 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
54113 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
54114 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
54115 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
54116 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
54117 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
54118 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
54119 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
54120 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
54121 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
54122 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
54123 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
54124 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
54125 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
54126 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
54127 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
54128 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54130 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
54131 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54132 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54133 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54134 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
54135 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
54139 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
54140 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
54141 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
54142 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
54144 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
54145 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
54146 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
54147 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
54148 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
54149 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
54151 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
54153 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
54154 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
54155 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
54156 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
54157 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
54158 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
54159 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
54160 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
54161 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
54162 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
54163 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
54164 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
54165 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
54166 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
54168 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
54170 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
54171 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
54172 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
54173 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
54174 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
54175 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
54176 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
54177 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
54179 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
54180 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
54181 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
54183 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
54184 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
54185 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
54186 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
54187 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
54189 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
54190 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54191 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54192 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
54193 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
54194 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
54196 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
54197 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54198 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
54200 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
54201 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
54203 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
54206 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
54208 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
54209 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
54210 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
54211 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
54212 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
54213 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
54214 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
54215 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
54216 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
54217 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
54218 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
54219 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
54220 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
54221 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
54222 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
54223 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
54224 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
54225 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
54226 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
54227 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
54228 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
54229 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
54230 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
54231 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
54232 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54233 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
54234 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
54235 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
54236 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
54237 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
54238 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
54239 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
54240 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
54241 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
54242 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
54243 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
54244 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
54245 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
54246 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
54247 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
54248 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
54249 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
54250 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
54251 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
54252 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
54253 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
54254 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
54255 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
54256 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
54257 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
54258 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
54259 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
54260 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
54261 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
54262 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
54263 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
54264 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
54265 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54266 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
54267 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
54268 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54269 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
54270 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
54271 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
54272 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
54273 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54274 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
54275 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
54276 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
54277 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
54278 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
54279 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
54280 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
54281 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
54282 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
54283 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
54284 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
54285 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
54286 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
54287 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
54288 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
54289 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
54290 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
54291 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
54292 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
54293 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
54294 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
54295 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
54296 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
54297 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
54298 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
54299 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
54300 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
54301 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
54302 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
54303 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
54304 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
54305 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
54306 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
54307 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
54308 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
54309 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
54310 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
54311 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
54312 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54313 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
54314 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
54315 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54316 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54317 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
54318 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
54319 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
54320 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
54321 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
54322 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
54323 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54324 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
54325 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
54326 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54327 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54328 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
54329 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
54330 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54331 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
54332 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
54333 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54334 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
54335 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
54336 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54337 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
54338 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
54339 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
54340 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54341 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
54342 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54343 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
54344 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
54345 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54346 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
54347 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
54348 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
54349 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54350 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
54351 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
54352 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
54353 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54354 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
54355 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
54356 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54357 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
54358 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
54359 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
54360 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
54361 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
54362 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54363 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
54364 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
54365 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
54366 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
54367 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
54368 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
54369 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
54370 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
54371 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54372 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
54373 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
54374 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
54375 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
54376 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54377 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
54378 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
54379 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
54380 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54381 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
54382 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
54383 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
54384 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
54385 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
54386 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
54387 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54388 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
54389 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
54390 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
54391 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
54392 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
54393 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
54394 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
54395 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
54396 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54397 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54398 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54399 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54400 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
54401 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
54402 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
54403 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
54404 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54405 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
54406 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
54407 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
54408 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
54409 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
54410 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
54411 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54412 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
54413 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
54414 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
54415 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54416 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
54417 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
54418 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
54419 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
54420 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
54421 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54422 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54423 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
54424 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
54425 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
54426 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54427 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
54428 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
54429 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
54430 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
54431 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
54432 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
54433 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54434 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
54435 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
54436 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
54437 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
54438 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
54439 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
54440 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
54441 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
54442 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
54443 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54444 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
54445 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
54446 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
54447 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54448 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
54449 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
54450 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
54451 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54452 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
54453 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54454 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
54455 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
54456 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
54457 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
54458 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
54459 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
54460 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
54461 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
54462 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
54463 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
54464 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54465 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
54466 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
54467 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54468 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
54469 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54470 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
54471 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
54472 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
54473 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54474 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
54475 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
54476 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
54477 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
54478 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
54479 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54480 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
54481 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
54482 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
54483 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
54484 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
54485 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
54486 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54487 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
54488 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
54489 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
54490 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
54491 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
54492 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
54493 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
54494 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
54495 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
54496 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
54497 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
54498 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
54499 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
54500 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
54501 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
54502 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
54503 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
54504 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
54505 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
54506 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
54507 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54508 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
54509 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
54510 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
54511 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
54512 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
54513 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
54514 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
54515 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
54516 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
54517 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
54518 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
54519 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
54520 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
54521 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
54522 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
54523 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54524 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54525 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
54526 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
54527 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
54528 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
54529 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
54530 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
54531 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
54532 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
54533 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
54534 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
54535 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
54536 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
54537 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
54538 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
54539 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
54540 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
54541 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
54542 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
54543 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
54544 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
54545 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
54546 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
54547 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
54548 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
54549 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
54550 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
54551 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
54552 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
54553 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
54554 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
54555 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
54556 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
54557 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
54558 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
54559 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54560 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54561 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
54562 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
54563 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
54564 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
54565 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
54566 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
54567 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
54568 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
54569 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54570 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
54571 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
54572 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
54573 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
54574 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
54575 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
54576 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
54577 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
54578 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
54579 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
54580 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
54581 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
54582 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
54583 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
54584 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
54585 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
54586 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
54587 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54588 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
54589 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
54590 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
54591 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
54592 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54593 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
54594 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
54595 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
54596 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
54597 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
54598 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54599 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
54600 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
54601 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54602 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
54603 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
54604 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54605 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54606 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
54607 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
54608 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
54609 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54610 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
54611 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
54612 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
54613 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
54614 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
54615 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
54616 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54617 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
54618 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
54619 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
54620 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
54621 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
54622 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
54623 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
54624 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
54625 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
54626 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
54627 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
54628 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
54629 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
54630 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
54631 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
54632 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
54633 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
54634 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
54635 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
54636 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
54637 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
54638 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
54639 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
54640 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54641 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54642 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54643 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
54644 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
54645 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
54646 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54647 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
54648 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
54649 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
54650 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
54651 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
54652 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
54653 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
54654 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
54655 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
54656 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
54657 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54658 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
54659 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54660 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
54661 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
54662 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
54663 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
54664 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54665 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
54666 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54667 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
54668 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54669 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
54670 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
54671 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54672 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
54673 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
54674 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
54675 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
54676 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
54677 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
54678 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
54679 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54680 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
54681 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
54682 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
54683 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
54684 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
54685 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
54686 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
54687 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
54688 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
54689 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54690 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54691 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
54692 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54693 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54694 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54695 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54696 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
54697 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
54698 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
54699 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
54700 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
54701 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
54702 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
54703 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
54704 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54705 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
54706 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54707 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
54708 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
54709 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
54710 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54711 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
54712 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
54713 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
54714 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
54715 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
54716 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
54717 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
54718 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
54719 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
54720 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
54721 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
54722 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
54723 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
54724 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
54725 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
54726 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
54727 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
54728 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54729 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
54730 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
54731 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54732 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54733 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54734 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54735 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54736 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
54737 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
54738 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
54739 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
54740 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
54741 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
54742 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
54743 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
54744 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
54745 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54746 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
54747 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
54748 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
54749 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
54750 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
54751 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
54752 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54753 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
54754 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
54755 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
54756 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
54757 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
54758 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
54759 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
54760 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
54761 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
54762 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
54763 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54764 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
54765 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
54766 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
54767 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
54768 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54769 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
54770 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54771 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
54772 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
54773 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
54774 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54775 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
54776 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
54777 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
54778 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
54779 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
54780 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
54781 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
54782 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
54783 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54784 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
54785 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
54786 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
54787 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
54788 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
54789 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
54790 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
54791 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54792 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
54793 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
54794 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
54795 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
54796 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54797 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
54798 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
54799 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54800 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
54801 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
54802 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
54803 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
54804 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
54805 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
54806 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
54807 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
54808 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
54809 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54810 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
54811 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
54812 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
54813 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
54814 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
54815 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
54816 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
54817 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
54818 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54819 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
54820 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
54821 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
54822 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
54823 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
54824 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54825 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
54826 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
54827 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
54828 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54829 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
54830 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54831 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54832 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54833 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54834 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
54835 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54836 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54837 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
54838 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54839 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
54840 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54841 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54842 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54843 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54844 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
54845 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
54846 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
54847 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54848 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54849 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
54850 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54851 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
54852 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
54853 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
54854 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
54855 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
54856 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
54857 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
54858 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54859 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54860 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54861 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54862 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54863 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54864 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54865 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54866 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54867 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54868 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
54869 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
54870 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
54871 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
54872 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54873 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
54874 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
54875 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
54876 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
54877 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54878 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
54879 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
54880 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
54881 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
54882 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
54883 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
54884 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
54885 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54886 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54887 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
54888 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54889 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
54890 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54891 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
54892 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
54893 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54894 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
54895 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54896 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
54897 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54898 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54899 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54900 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
54901 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
54902 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54903 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
54904 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54905 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
54906 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
54907 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
54908 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
54909 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
54910 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
54911 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54912 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
54913 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
54914 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
54915 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
54916 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
54917 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
54918 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54919 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
54920 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
54921 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
54922 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
54923 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
54924 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
54925 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
54926 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
54927 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
54928 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
54929 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
54930 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
54931 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
54932 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
54933 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
54934 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
54935 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
54936 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
54937 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
54938 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
54939 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
54940 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
54941 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
54942 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54943 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
54944 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
54945 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
54946 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
54947 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
54948 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
54949 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
54950 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54951 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54952 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54953 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54954 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54955 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54956 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54957 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54958 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54959 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54960 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54961 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54962 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54963 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54964 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54965 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54966 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54967 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54968 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54969 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54970 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54971 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54972 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54973 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54974 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54975 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54976 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54977 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54978 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54979 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54980 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54981 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54982 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54983 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54984 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54985 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54986 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54987 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54988 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54989 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54990 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54991 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54992 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54993 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54994 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54995 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54996 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54997 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54998 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54999 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
55000 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55001 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
55002 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
55003 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
55004 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
55005 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
55006 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
55007 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
55008 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
55009 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
55010 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
55011 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
55012 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
55013 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
55014 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
55015 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
55016 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
55017 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
55018 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
55019 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55020 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
55021 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55022 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
55023 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55024 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55025 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
55026 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
55027 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
55028 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
55029 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
55030 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
55031 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
55032 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55033 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55034 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
55035 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
55036 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
55037 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
55038 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
55039 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55040 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
55041 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55042 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
55043 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55044 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
55045 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55046 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
55047 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
55048 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
55049 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
55050 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
55051 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
55052 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
55053 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
55054 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
55055 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
55056 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
55057 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
55058 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55059 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
55060 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
55061 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
55062 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
55063 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
55064 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
55065 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
55066 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
55067 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
55068 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
55069 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
55070 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
55071 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55072 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
55073 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
55074 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
55075 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
55076 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55077 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
55078 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
55079 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
55080 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55081 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
55082 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
55083 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
55084 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
55085 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
55086 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
55087 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
55088 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
55089 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
55090 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
55091 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55092 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55093 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
55094 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55095 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
55096 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
55097 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
55098 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
55099 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
55100 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
55101 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
55102 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
55103 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
55104 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
55105 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
55106 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
55107 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55108 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
55109 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
55110 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
55111 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
55112 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
55113 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
55114 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
55115 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
55116 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
55117 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55118 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
55119 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
55120 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
55121 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
55122 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
55123 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55124 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55125 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55126 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
55127 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
55128 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
55129 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55130 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
55131 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
55132 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
55133 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
55134 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
55135 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
55136 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
55137 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55138 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
55139 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
55140 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
55141 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
55142 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
55143 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
55144 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55145 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
55146 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
55147 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
55148 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
55149 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
55150 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
55151 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
55152 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
55153 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
55154 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55155 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
55156 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
55157 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
55158 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
55159 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
55160 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55161 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
55162 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
55163 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
55164 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
55165 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
55166 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
55167 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
55168 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
55169 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
55170 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
55171 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
55172 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
55173 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
55174 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
55175 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
55176 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
55177 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
55178 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
55179 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
55180 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
55181 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
55182 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
55183 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
55184 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
55185 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
55186 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55187 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
55188 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
55189 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
55190 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
55191 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
55192 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
55193 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
55194 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
55195 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
55196 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
55197 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
55198 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
55199 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
55200 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
55201 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
55202 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
55203 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
55204 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
55205 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
55206 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
55207 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
55208 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
55209 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
55210 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
55211 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
55212 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
55213 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
55214 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
55215 { NULL, NULL, 0, NULL }
55216 };
55217
55218
55219 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
55220
55221 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
55222 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
55223 }
55224 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
55225 return (void *)((wxSizer *) ((wxBoxSizer *) x));
55226 }
55227 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
55228 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
55229 }
55230 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
55231 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55232 }
55233 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
55234 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55235 }
55236 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
55237 return (void *)((wxSizer *) ((wxGridSizer *) x));
55238 }
55239 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
55240 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
55241 }
55242 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
55243 return (void *)((wxSizer *) ((wxPySizer *) x));
55244 }
55245 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
55246 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
55247 }
55248 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
55249 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55250 }
55251 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
55252 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
55253 }
55254 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
55255 return (void *)((wxEvent *) ((wxMenuEvent *) x));
55256 }
55257 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
55258 return (void *)((wxEvent *) ((wxCloseEvent *) x));
55259 }
55260 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
55261 return (void *)((wxEvent *) ((wxMouseEvent *) x));
55262 }
55263 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
55264 return (void *)((wxEvent *) ((wxEraseEvent *) x));
55265 }
55266 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
55267 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
55268 }
55269 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
55270 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
55271 }
55272 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
55273 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
55274 }
55275 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
55276 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
55277 }
55278 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
55279 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
55280 }
55281 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
55282 return (void *)((wxEvent *) ((wxPyEvent *) x));
55283 }
55284 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
55285 return (void *)((wxEvent *) ((wxIdleEvent *) x));
55286 }
55287 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
55288 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
55289 }
55290 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
55291 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
55292 }
55293 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
55294 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
55295 }
55296 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
55297 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
55298 }
55299 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
55300 return (void *)((wxEvent *) ((wxActivateEvent *) x));
55301 }
55302 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
55303 return (void *)((wxEvent *) ((wxSizeEvent *) x));
55304 }
55305 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
55306 return (void *)((wxEvent *) ((wxMoveEvent *) x));
55307 }
55308 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
55309 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
55310 }
55311 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
55312 return (void *)((wxEvent *) ((wxPaintEvent *) x));
55313 }
55314 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
55315 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
55316 }
55317 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
55318 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
55319 }
55320 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
55321 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
55322 }
55323 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
55324 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
55325 }
55326 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
55327 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
55328 }
55329 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
55330 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55331 }
55332 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
55333 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
55334 }
55335 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
55336 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
55337 }
55338 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
55339 return (void *)((wxEvent *) ((wxFocusEvent *) x));
55340 }
55341 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
55342 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
55343 }
55344 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
55345 return (void *)((wxEvent *) ((wxShowEvent *) x));
55346 }
55347 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
55348 return (void *)((wxEvent *) ((wxCommandEvent *) x));
55349 }
55350 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
55351 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
55352 }
55353 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
55354 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55355 }
55356 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
55357 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
55358 }
55359 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
55360 return (void *)((wxEvent *) ((wxKeyEvent *) x));
55361 }
55362 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
55363 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
55364 }
55365 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
55366 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
55367 }
55368 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
55369 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
55370 }
55371 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
55372 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
55373 }
55374 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
55375 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
55376 }
55377 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
55378 return (void *)((wxControl *) ((wxControlWithItems *) x));
55379 }
55380 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
55381 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
55382 }
55383 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
55384 return (void *)((wxEvtHandler *) ((wxWindow *) x));
55385 }
55386 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
55387 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55388 }
55389 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
55390 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
55391 }
55392 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
55393 return (void *)((wxEvtHandler *) ((wxValidator *) x));
55394 }
55395 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
55396 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
55397 }
55398 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
55399 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
55400 }
55401 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
55402 return (void *)((wxEvtHandler *) ((wxMenu *) x));
55403 }
55404 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
55405 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
55406 }
55407 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
55408 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
55409 }
55410 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
55411 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
55412 }
55413 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
55414 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
55415 }
55416 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
55417 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
55418 }
55419 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
55420 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55421 }
55422 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
55423 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
55424 }
55425 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
55426 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
55427 }
55428 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
55429 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
55430 }
55431 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
55432 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55433 }
55434 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
55435 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55436 }
55437 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
55438 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
55439 }
55440 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
55441 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
55442 }
55443 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
55444 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
55445 }
55446 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
55447 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
55448 }
55449 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
55450 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
55451 }
55452 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
55453 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
55454 }
55455 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
55456 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
55457 }
55458 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
55459 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
55460 }
55461 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
55462 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
55463 }
55464 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
55465 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
55466 }
55467 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
55468 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
55469 }
55470 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
55471 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
55472 }
55473 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
55474 return (void *)((wxObject *) ((wxSizerItem *) x));
55475 }
55476 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
55477 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
55478 }
55479 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
55480 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
55481 }
55482 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
55483 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
55484 }
55485 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
55486 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
55487 }
55488 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
55489 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
55490 }
55491 static void *_p_wxSizerTo_p_wxObject(void *x) {
55492 return (void *)((wxObject *) ((wxSizer *) x));
55493 }
55494 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
55495 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
55496 }
55497 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
55498 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
55499 }
55500 static void *_p_wxEventTo_p_wxObject(void *x) {
55501 return (void *)((wxObject *) ((wxEvent *) x));
55502 }
55503 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
55504 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
55505 }
55506 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
55507 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
55508 }
55509 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
55510 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
55511 }
55512 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
55513 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
55514 }
55515 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
55516 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
55517 }
55518 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
55519 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
55520 }
55521 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
55522 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
55523 }
55524 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
55525 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
55526 }
55527 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
55528 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
55529 }
55530 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
55531 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
55532 }
55533 static void *_p_wxControlTo_p_wxObject(void *x) {
55534 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
55535 }
55536 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
55537 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
55538 }
55539 static void *_p_wxFSFileTo_p_wxObject(void *x) {
55540 return (void *)((wxObject *) ((wxFSFile *) x));
55541 }
55542 static void *_p_wxPySizerTo_p_wxObject(void *x) {
55543 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
55544 }
55545 static void *_p_wxPyEventTo_p_wxObject(void *x) {
55546 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
55547 }
55548 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
55549 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
55550 }
55551 static void *_p_wxShowEventTo_p_wxObject(void *x) {
55552 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
55553 }
55554 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
55555 return (void *)((wxObject *) ((wxMenuItem *) x));
55556 }
55557 static void *_p_wxDateEventTo_p_wxObject(void *x) {
55558 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
55559 }
55560 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
55561 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
55562 }
55563 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
55564 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
55565 }
55566 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
55567 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
55568 }
55569 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
55570 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
55571 }
55572 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
55573 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
55574 }
55575 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
55576 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
55577 }
55578 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
55579 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
55580 }
55581 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
55582 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
55583 }
55584 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
55585 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
55586 }
55587 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
55588 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
55589 }
55590 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
55591 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
55592 }
55593 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
55594 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
55595 }
55596 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
55597 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
55598 }
55599 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
55600 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
55601 }
55602 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
55603 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
55604 }
55605 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
55606 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
55607 }
55608 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
55609 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
55610 }
55611 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
55612 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
55613 }
55614 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
55615 return (void *)((wxObject *) ((wxImageHandler *) x));
55616 }
55617 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
55618 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
55619 }
55620 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
55621 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
55622 }
55623 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
55624 return (void *)((wxObject *) ((wxEvtHandler *) x));
55625 }
55626 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
55627 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
55628 }
55629 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
55630 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
55631 }
55632 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
55633 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
55634 }
55635 static void *_p_wxImageTo_p_wxObject(void *x) {
55636 return (void *)((wxObject *) ((wxImage *) x));
55637 }
55638 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
55639 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
55640 }
55641 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
55642 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55643 }
55644 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
55645 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
55646 }
55647 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
55648 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
55649 }
55650 static void *_p_wxWindowTo_p_wxObject(void *x) {
55651 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
55652 }
55653 static void *_p_wxMenuTo_p_wxObject(void *x) {
55654 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
55655 }
55656 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
55657 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
55658 }
55659 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
55660 return (void *)((wxObject *) ((wxFileSystem *) x));
55661 }
55662 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
55663 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
55664 }
55665 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
55666 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
55667 }
55668 static void *_p_wxPyAppTo_p_wxObject(void *x) {
55669 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
55670 }
55671 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
55672 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
55673 }
55674 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
55675 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
55676 }
55677 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
55678 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
55679 }
55680 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
55681 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
55682 }
55683 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
55684 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
55685 }
55686 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
55687 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
55688 }
55689 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
55690 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
55691 }
55692 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
55693 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
55694 }
55695 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
55696 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
55697 }
55698 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
55699 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
55700 }
55701 static void *_p_wxValidatorTo_p_wxObject(void *x) {
55702 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
55703 }
55704 static void *_p_wxControlTo_p_wxWindow(void *x) {
55705 return (void *)((wxWindow *) ((wxControl *) x));
55706 }
55707 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
55708 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
55709 }
55710 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
55711 return (void *)((wxWindow *) ((wxMenuBar *) x));
55712 }
55713 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
55714 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
55715 }
55716 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
55717 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
55718 }
55719 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
55720 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
55721 }
55722 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
55723 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
55724 }
55725 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
55726 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
55727 }
55728 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
55729 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
55730 }
55731 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
55732 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
55733 }
55734 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
55735 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
55736 }
55737 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
55738 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
55739 }
55740 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
55741 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
55742 }
55743 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
55744 return (void *)((wxValidator *) ((wxPyValidator *) x));
55745 }
55746 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
55747 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
55748 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};
55749 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
55750 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
55751 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
55752 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
55753 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
55754 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
55755 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
55756 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
55757 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
55758 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
55759 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
55760 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
55761 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
55762 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
55763 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
55764 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
55765 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
55766 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
55767 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
55768 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
55769 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
55770 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
55771 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
55772 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
55773 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
55774 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
55775 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
55776 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
55777 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
55778 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
55779 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
55780 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
55781 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
55782 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
55783 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
55784 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
55785 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
55786 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
55787 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
55788 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
55789 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
55790 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
55791 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
55792 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
55793 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
55794 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
55795 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
55796 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
55797 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
55798 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
55799 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
55800 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
55801 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
55802 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
55803 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
55804 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
55805 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
55806 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
55807 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
55808 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
55809 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
55810 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
55811 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
55812 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
55813 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
55814 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
55815 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
55816 static swig_type_info _swigt__p_wxLayoutDirection = {"_p_wxLayoutDirection", "wxLayoutDirection *", 0, 0, (void*)0, 0};
55817 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
55818 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
55819 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
55820 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
55821 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
55822 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
55823 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
55824 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
55825 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
55826 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
55827 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
55828 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
55829 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
55830 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
55831 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
55832 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
55833 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
55834 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
55835 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
55836 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
55837 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
55838 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
55839 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
55840 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
55841 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
55842 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
55843 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
55844 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
55845 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
55846 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
55847 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
55848 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
55849 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
55850 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
55851 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
55852 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
55853 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
55854 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
55855 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
55856 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
55857 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
55858 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
55859 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
55860 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
55861 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
55862 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
55863 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
55864 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
55865 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
55866 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
55867 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
55868 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
55869 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
55870 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
55871 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
55872 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
55873 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
55874 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
55875 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
55876 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
55877 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
55878 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
55879
55880 static swig_type_info *swig_type_initial[] = {
55881 &_swigt__p_buffer,
55882 &_swigt__p_char,
55883 &_swigt__p_form_ops_t,
55884 &_swigt__p_int,
55885 &_swigt__p_long,
55886 &_swigt__p_unsigned_char,
55887 &_swigt__p_unsigned_int,
55888 &_swigt__p_unsigned_long,
55889 &_swigt__p_wxANIHandler,
55890 &_swigt__p_wxAcceleratorEntry,
55891 &_swigt__p_wxAcceleratorTable,
55892 &_swigt__p_wxActivateEvent,
55893 &_swigt__p_wxAppTraits,
55894 &_swigt__p_wxArrayString,
55895 &_swigt__p_wxBMPHandler,
55896 &_swigt__p_wxBitmap,
55897 &_swigt__p_wxBoxSizer,
55898 &_swigt__p_wxButton,
55899 &_swigt__p_wxCURHandler,
55900 &_swigt__p_wxCaret,
55901 &_swigt__p_wxChildFocusEvent,
55902 &_swigt__p_wxClipboardTextEvent,
55903 &_swigt__p_wxCloseEvent,
55904 &_swigt__p_wxColour,
55905 &_swigt__p_wxCommandEvent,
55906 &_swigt__p_wxContextMenuEvent,
55907 &_swigt__p_wxControl,
55908 &_swigt__p_wxControlWithItems,
55909 &_swigt__p_wxCursor,
55910 &_swigt__p_wxDC,
55911 &_swigt__p_wxDateEvent,
55912 &_swigt__p_wxDateTime,
55913 &_swigt__p_wxDisplayChangedEvent,
55914 &_swigt__p_wxDropFilesEvent,
55915 &_swigt__p_wxDuplexMode,
55916 &_swigt__p_wxEraseEvent,
55917 &_swigt__p_wxEvent,
55918 &_swigt__p_wxEventLoop,
55919 &_swigt__p_wxEventLoopActivator,
55920 &_swigt__p_wxEvtHandler,
55921 &_swigt__p_wxFSFile,
55922 &_swigt__p_wxFileSystem,
55923 &_swigt__p_wxFileSystemHandler,
55924 &_swigt__p_wxFlexGridSizer,
55925 &_swigt__p_wxFocusEvent,
55926 &_swigt__p_wxFont,
55927 &_swigt__p_wxFrame,
55928 &_swigt__p_wxGBPosition,
55929 &_swigt__p_wxGBSizerItem,
55930 &_swigt__p_wxGBSpan,
55931 &_swigt__p_wxGIFHandler,
55932 &_swigt__p_wxGridBagSizer,
55933 &_swigt__p_wxGridSizer,
55934 &_swigt__p_wxHelpEvent__Origin,
55935 &_swigt__p_wxICOHandler,
55936 &_swigt__p_wxIconizeEvent,
55937 &_swigt__p_wxIdleEvent,
55938 &_swigt__p_wxImage,
55939 &_swigt__p_wxImageHandler,
55940 &_swigt__p_wxImageHistogram,
55941 &_swigt__p_wxImage_HSVValue,
55942 &_swigt__p_wxImage_RGBValue,
55943 &_swigt__p_wxIndividualLayoutConstraint,
55944 &_swigt__p_wxInitDialogEvent,
55945 &_swigt__p_wxInputStream,
55946 &_swigt__p_wxInternetFSHandler,
55947 &_swigt__p_wxItemContainer,
55948 &_swigt__p_wxJPEGHandler,
55949 &_swigt__p_wxKeyEvent,
55950 &_swigt__p_wxLayoutConstraints,
55951 &_swigt__p_wxLayoutDirection,
55952 &_swigt__p_wxMaximizeEvent,
55953 &_swigt__p_wxMemoryFSHandler,
55954 &_swigt__p_wxMenu,
55955 &_swigt__p_wxMenuBar,
55956 &_swigt__p_wxMenuBarBase,
55957 &_swigt__p_wxMenuEvent,
55958 &_swigt__p_wxMenuItem,
55959 &_swigt__p_wxMouseCaptureChangedEvent,
55960 &_swigt__p_wxMouseCaptureLostEvent,
55961 &_swigt__p_wxMouseEvent,
55962 &_swigt__p_wxMoveEvent,
55963 &_swigt__p_wxNavigationKeyEvent,
55964 &_swigt__p_wxNcPaintEvent,
55965 &_swigt__p_wxNotifyEvent,
55966 &_swigt__p_wxObject,
55967 &_swigt__p_wxOutputStream,
55968 &_swigt__p_wxPCXHandler,
55969 &_swigt__p_wxPNGHandler,
55970 &_swigt__p_wxPNMHandler,
55971 &_swigt__p_wxPaintEvent,
55972 &_swigt__p_wxPaletteChangedEvent,
55973 &_swigt__p_wxPaperSize,
55974 &_swigt__p_wxPoint,
55975 &_swigt__p_wxPoint2D,
55976 &_swigt__p_wxPropagateOnce,
55977 &_swigt__p_wxPropagationDisabler,
55978 &_swigt__p_wxPyApp,
55979 &_swigt__p_wxPyCommandEvent,
55980 &_swigt__p_wxPyDropTarget,
55981 &_swigt__p_wxPyEvent,
55982 &_swigt__p_wxPyFileSystemHandler,
55983 &_swigt__p_wxPyImageHandler,
55984 &_swigt__p_wxPyInputStream,
55985 &_swigt__p_wxPySizer,
55986 &_swigt__p_wxPyValidator,
55987 &_swigt__p_wxQuantize,
55988 &_swigt__p_wxQueryNewPaletteEvent,
55989 &_swigt__p_wxRealPoint,
55990 &_swigt__p_wxRect,
55991 &_swigt__p_wxRegion,
55992 &_swigt__p_wxScrollEvent,
55993 &_swigt__p_wxScrollWinEvent,
55994 &_swigt__p_wxSetCursorEvent,
55995 &_swigt__p_wxShowEvent,
55996 &_swigt__p_wxSize,
55997 &_swigt__p_wxSizeEvent,
55998 &_swigt__p_wxSizer,
55999 &_swigt__p_wxSizerItem,
56000 &_swigt__p_wxStaticBox,
56001 &_swigt__p_wxStaticBoxSizer,
56002 &_swigt__p_wxStdDialogButtonSizer,
56003 &_swigt__p_wxSysColourChangedEvent,
56004 &_swigt__p_wxTIFFHandler,
56005 &_swigt__p_wxToolTip,
56006 &_swigt__p_wxUpdateUIEvent,
56007 &_swigt__p_wxValidator,
56008 &_swigt__p_wxVisualAttributes,
56009 &_swigt__p_wxWindow,
56010 &_swigt__p_wxWindowCreateEvent,
56011 &_swigt__p_wxWindowDestroyEvent,
56012 &_swigt__p_wxXPMHandler,
56013 &_swigt__p_wxZipFSHandler,
56014 };
56015
56016 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
56017 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
56018 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
56019 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
56020 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
56021 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
56022 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
56023 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
56024 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
56025 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
56026 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
56027 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
56028 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
56029 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
56030 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}};
56031 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
56032 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}};
56033 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
56034 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}};
56035 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
56036 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56037 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
56038 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
56039 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
56040 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}};
56041 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56042 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}};
56043 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
56044 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
56045 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
56046 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
56047 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
56048 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56049 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
56050 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
56051 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
56052 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}};
56053 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
56054 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
56055 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}};
56056 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
56057 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
56058 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}};
56059 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}};
56060 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
56061 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
56062 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
56063 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
56064 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
56065 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
56066 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
56067 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
56068 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}};
56069 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
56070 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}};
56071 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56072 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
56073 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
56074 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}};
56075 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
56076 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
56077 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
56078 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
56079 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
56080 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
56081 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56082 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}};
56083 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
56084 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56085 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
56086 static swig_cast_info _swigc__p_wxLayoutDirection[] = { {&_swigt__p_wxLayoutDirection, 0, 0, 0},{0, 0, 0, 0}};
56087 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56088 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56089 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
56090 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
56091 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
56092 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
56093 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
56094 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56095 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
56096 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
56097 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
56098 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
56099 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56100 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
56101 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}};
56102 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
56103 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
56104 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
56105 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
56106 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
56107 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56108 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
56109 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
56110 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
56111 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
56112 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
56113 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
56114 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
56115 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
56116 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
56117 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
56118 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
56119 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
56120 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
56121 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
56122 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
56123 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
56124 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
56125 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
56126 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
56127 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
56128 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
56129 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
56130 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
56131 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
56132 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
56133 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}};
56134 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}};
56135 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
56136 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
56137 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
56138 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
56139 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
56140 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
56141 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
56142 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}};
56143 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
56144 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}};
56145 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
56146 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
56147 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
56148 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
56149
56150 static swig_cast_info *swig_cast_initial[] = {
56151 _swigc__p_buffer,
56152 _swigc__p_char,
56153 _swigc__p_form_ops_t,
56154 _swigc__p_int,
56155 _swigc__p_long,
56156 _swigc__p_unsigned_char,
56157 _swigc__p_unsigned_int,
56158 _swigc__p_unsigned_long,
56159 _swigc__p_wxANIHandler,
56160 _swigc__p_wxAcceleratorEntry,
56161 _swigc__p_wxAcceleratorTable,
56162 _swigc__p_wxActivateEvent,
56163 _swigc__p_wxAppTraits,
56164 _swigc__p_wxArrayString,
56165 _swigc__p_wxBMPHandler,
56166 _swigc__p_wxBitmap,
56167 _swigc__p_wxBoxSizer,
56168 _swigc__p_wxButton,
56169 _swigc__p_wxCURHandler,
56170 _swigc__p_wxCaret,
56171 _swigc__p_wxChildFocusEvent,
56172 _swigc__p_wxClipboardTextEvent,
56173 _swigc__p_wxCloseEvent,
56174 _swigc__p_wxColour,
56175 _swigc__p_wxCommandEvent,
56176 _swigc__p_wxContextMenuEvent,
56177 _swigc__p_wxControl,
56178 _swigc__p_wxControlWithItems,
56179 _swigc__p_wxCursor,
56180 _swigc__p_wxDC,
56181 _swigc__p_wxDateEvent,
56182 _swigc__p_wxDateTime,
56183 _swigc__p_wxDisplayChangedEvent,
56184 _swigc__p_wxDropFilesEvent,
56185 _swigc__p_wxDuplexMode,
56186 _swigc__p_wxEraseEvent,
56187 _swigc__p_wxEvent,
56188 _swigc__p_wxEventLoop,
56189 _swigc__p_wxEventLoopActivator,
56190 _swigc__p_wxEvtHandler,
56191 _swigc__p_wxFSFile,
56192 _swigc__p_wxFileSystem,
56193 _swigc__p_wxFileSystemHandler,
56194 _swigc__p_wxFlexGridSizer,
56195 _swigc__p_wxFocusEvent,
56196 _swigc__p_wxFont,
56197 _swigc__p_wxFrame,
56198 _swigc__p_wxGBPosition,
56199 _swigc__p_wxGBSizerItem,
56200 _swigc__p_wxGBSpan,
56201 _swigc__p_wxGIFHandler,
56202 _swigc__p_wxGridBagSizer,
56203 _swigc__p_wxGridSizer,
56204 _swigc__p_wxHelpEvent__Origin,
56205 _swigc__p_wxICOHandler,
56206 _swigc__p_wxIconizeEvent,
56207 _swigc__p_wxIdleEvent,
56208 _swigc__p_wxImage,
56209 _swigc__p_wxImageHandler,
56210 _swigc__p_wxImageHistogram,
56211 _swigc__p_wxImage_HSVValue,
56212 _swigc__p_wxImage_RGBValue,
56213 _swigc__p_wxIndividualLayoutConstraint,
56214 _swigc__p_wxInitDialogEvent,
56215 _swigc__p_wxInputStream,
56216 _swigc__p_wxInternetFSHandler,
56217 _swigc__p_wxItemContainer,
56218 _swigc__p_wxJPEGHandler,
56219 _swigc__p_wxKeyEvent,
56220 _swigc__p_wxLayoutConstraints,
56221 _swigc__p_wxLayoutDirection,
56222 _swigc__p_wxMaximizeEvent,
56223 _swigc__p_wxMemoryFSHandler,
56224 _swigc__p_wxMenu,
56225 _swigc__p_wxMenuBar,
56226 _swigc__p_wxMenuBarBase,
56227 _swigc__p_wxMenuEvent,
56228 _swigc__p_wxMenuItem,
56229 _swigc__p_wxMouseCaptureChangedEvent,
56230 _swigc__p_wxMouseCaptureLostEvent,
56231 _swigc__p_wxMouseEvent,
56232 _swigc__p_wxMoveEvent,
56233 _swigc__p_wxNavigationKeyEvent,
56234 _swigc__p_wxNcPaintEvent,
56235 _swigc__p_wxNotifyEvent,
56236 _swigc__p_wxObject,
56237 _swigc__p_wxOutputStream,
56238 _swigc__p_wxPCXHandler,
56239 _swigc__p_wxPNGHandler,
56240 _swigc__p_wxPNMHandler,
56241 _swigc__p_wxPaintEvent,
56242 _swigc__p_wxPaletteChangedEvent,
56243 _swigc__p_wxPaperSize,
56244 _swigc__p_wxPoint,
56245 _swigc__p_wxPoint2D,
56246 _swigc__p_wxPropagateOnce,
56247 _swigc__p_wxPropagationDisabler,
56248 _swigc__p_wxPyApp,
56249 _swigc__p_wxPyCommandEvent,
56250 _swigc__p_wxPyDropTarget,
56251 _swigc__p_wxPyEvent,
56252 _swigc__p_wxPyFileSystemHandler,
56253 _swigc__p_wxPyImageHandler,
56254 _swigc__p_wxPyInputStream,
56255 _swigc__p_wxPySizer,
56256 _swigc__p_wxPyValidator,
56257 _swigc__p_wxQuantize,
56258 _swigc__p_wxQueryNewPaletteEvent,
56259 _swigc__p_wxRealPoint,
56260 _swigc__p_wxRect,
56261 _swigc__p_wxRegion,
56262 _swigc__p_wxScrollEvent,
56263 _swigc__p_wxScrollWinEvent,
56264 _swigc__p_wxSetCursorEvent,
56265 _swigc__p_wxShowEvent,
56266 _swigc__p_wxSize,
56267 _swigc__p_wxSizeEvent,
56268 _swigc__p_wxSizer,
56269 _swigc__p_wxSizerItem,
56270 _swigc__p_wxStaticBox,
56271 _swigc__p_wxStaticBoxSizer,
56272 _swigc__p_wxStdDialogButtonSizer,
56273 _swigc__p_wxSysColourChangedEvent,
56274 _swigc__p_wxTIFFHandler,
56275 _swigc__p_wxToolTip,
56276 _swigc__p_wxUpdateUIEvent,
56277 _swigc__p_wxValidator,
56278 _swigc__p_wxVisualAttributes,
56279 _swigc__p_wxWindow,
56280 _swigc__p_wxWindowCreateEvent,
56281 _swigc__p_wxWindowDestroyEvent,
56282 _swigc__p_wxXPMHandler,
56283 _swigc__p_wxZipFSHandler,
56284 };
56285
56286
56287 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
56288
56289 static swig_const_info swig_const_table[] = {
56290 {0, 0, 0, 0.0, 0, 0}};
56291
56292 #ifdef __cplusplus
56293 }
56294 #endif
56295 /* -----------------------------------------------------------------------------
56296 * Type initialization:
56297 * This problem is tough by the requirement that no dynamic
56298 * memory is used. Also, since swig_type_info structures store pointers to
56299 * swig_cast_info structures and swig_cast_info structures store pointers back
56300 * to swig_type_info structures, we need some lookup code at initialization.
56301 * The idea is that swig generates all the structures that are needed.
56302 * The runtime then collects these partially filled structures.
56303 * The SWIG_InitializeModule function takes these initial arrays out of
56304 * swig_module, and does all the lookup, filling in the swig_module.types
56305 * array with the correct data and linking the correct swig_cast_info
56306 * structures together.
56307 *
56308 * The generated swig_type_info structures are assigned staticly to an initial
56309 * array. We just loop though that array, and handle each type individually.
56310 * First we lookup if this type has been already loaded, and if so, use the
56311 * loaded structure instead of the generated one. Then we have to fill in the
56312 * cast linked list. The cast data is initially stored in something like a
56313 * two-dimensional array. Each row corresponds to a type (there are the same
56314 * number of rows as there are in the swig_type_initial array). Each entry in
56315 * a column is one of the swig_cast_info structures for that type.
56316 * The cast_initial array is actually an array of arrays, because each row has
56317 * a variable number of columns. So to actually build the cast linked list,
56318 * we find the array of casts associated with the type, and loop through it
56319 * adding the casts to the list. The one last trick we need to do is making
56320 * sure the type pointer in the swig_cast_info struct is correct.
56321 *
56322 * First off, we lookup the cast->type name to see if it is already loaded.
56323 * There are three cases to handle:
56324 * 1) If the cast->type has already been loaded AND the type we are adding
56325 * casting info to has not been loaded (it is in this module), THEN we
56326 * replace the cast->type pointer with the type pointer that has already
56327 * been loaded.
56328 * 2) If BOTH types (the one we are adding casting info to, and the
56329 * cast->type) are loaded, THEN the cast info has already been loaded by
56330 * the previous module so we just ignore it.
56331 * 3) Finally, if cast->type has not already been loaded, then we add that
56332 * swig_cast_info to the linked list (because the cast->type) pointer will
56333 * be correct.
56334 * ----------------------------------------------------------------------------- */
56335
56336 #ifdef __cplusplus
56337 extern "C" {
56338 #if 0
56339 } /* c-mode */
56340 #endif
56341 #endif
56342
56343 #if 0
56344 #define SWIGRUNTIME_DEBUG
56345 #endif
56346
56347 SWIGRUNTIME void
56348 SWIG_InitializeModule(void *clientdata) {
56349 size_t i;
56350 swig_module_info *module_head;
56351 static int init_run = 0;
56352
56353 clientdata = clientdata;
56354
56355 if (init_run) return;
56356 init_run = 1;
56357
56358 /* Initialize the swig_module */
56359 swig_module.type_initial = swig_type_initial;
56360 swig_module.cast_initial = swig_cast_initial;
56361
56362 /* Try and load any already created modules */
56363 module_head = SWIG_GetModule(clientdata);
56364 if (module_head) {
56365 swig_module.next = module_head->next;
56366 module_head->next = &swig_module;
56367 } else {
56368 /* This is the first module loaded */
56369 swig_module.next = &swig_module;
56370 SWIG_SetModule(clientdata, &swig_module);
56371 }
56372
56373 /* Now work on filling in swig_module.types */
56374 #ifdef SWIGRUNTIME_DEBUG
56375 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
56376 #endif
56377 for (i = 0; i < swig_module.size; ++i) {
56378 swig_type_info *type = 0;
56379 swig_type_info *ret;
56380 swig_cast_info *cast;
56381
56382 #ifdef SWIGRUNTIME_DEBUG
56383 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56384 #endif
56385
56386 /* if there is another module already loaded */
56387 if (swig_module.next != &swig_module) {
56388 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
56389 }
56390 if (type) {
56391 /* Overwrite clientdata field */
56392 #ifdef SWIGRUNTIME_DEBUG
56393 printf("SWIG_InitializeModule: found type %s\n", type->name);
56394 #endif
56395 if (swig_module.type_initial[i]->clientdata) {
56396 type->clientdata = swig_module.type_initial[i]->clientdata;
56397 #ifdef SWIGRUNTIME_DEBUG
56398 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
56399 #endif
56400 }
56401 } else {
56402 type = swig_module.type_initial[i];
56403 }
56404
56405 /* Insert casting types */
56406 cast = swig_module.cast_initial[i];
56407 while (cast->type) {
56408 /* Don't need to add information already in the list */
56409 ret = 0;
56410 #ifdef SWIGRUNTIME_DEBUG
56411 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
56412 #endif
56413 if (swig_module.next != &swig_module) {
56414 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
56415 #ifdef SWIGRUNTIME_DEBUG
56416 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
56417 #endif
56418 }
56419 if (ret) {
56420 if (type == swig_module.type_initial[i]) {
56421 #ifdef SWIGRUNTIME_DEBUG
56422 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
56423 #endif
56424 cast->type = ret;
56425 ret = 0;
56426 } else {
56427 /* Check for casting already in the list */
56428 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
56429 #ifdef SWIGRUNTIME_DEBUG
56430 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
56431 #endif
56432 if (!ocast) ret = 0;
56433 }
56434 }
56435
56436 if (!ret) {
56437 #ifdef SWIGRUNTIME_DEBUG
56438 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
56439 #endif
56440 if (type->cast) {
56441 type->cast->prev = cast;
56442 cast->next = type->cast;
56443 }
56444 type->cast = cast;
56445 }
56446 cast++;
56447 }
56448 /* Set entry in modules->types array equal to the type */
56449 swig_module.types[i] = type;
56450 }
56451 swig_module.types[i] = 0;
56452
56453 #ifdef SWIGRUNTIME_DEBUG
56454 printf("**** SWIG_InitializeModule: Cast List ******\n");
56455 for (i = 0; i < swig_module.size; ++i) {
56456 int j = 0;
56457 swig_cast_info *cast = swig_module.cast_initial[i];
56458 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
56459 while (cast->type) {
56460 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
56461 cast++;
56462 ++j;
56463 }
56464 printf("---- Total casts: %d\n",j);
56465 }
56466 printf("**** SWIG_InitializeModule: Cast List ******\n");
56467 #endif
56468 }
56469
56470 /* This function will propagate the clientdata field of type to
56471 * any new swig_type_info structures that have been added into the list
56472 * of equivalent types. It is like calling
56473 * SWIG_TypeClientData(type, clientdata) a second time.
56474 */
56475 SWIGRUNTIME void
56476 SWIG_PropagateClientData(void) {
56477 size_t i;
56478 swig_cast_info *equiv;
56479 static int init_run = 0;
56480
56481 if (init_run) return;
56482 init_run = 1;
56483
56484 for (i = 0; i < swig_module.size; i++) {
56485 if (swig_module.types[i]->clientdata) {
56486 equiv = swig_module.types[i]->cast;
56487 while (equiv) {
56488 if (!equiv->converter) {
56489 if (equiv->type && !equiv->type->clientdata)
56490 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
56491 }
56492 equiv = equiv->next;
56493 }
56494 }
56495 }
56496 }
56497
56498 #ifdef __cplusplus
56499 #if 0
56500 {
56501 /* c-mode */
56502 #endif
56503 }
56504 #endif
56505
56506
56507
56508 #ifdef __cplusplus
56509 extern "C" {
56510 #endif
56511
56512 /* Python-specific SWIG API */
56513 #define SWIG_newvarlink() SWIG_Python_newvarlink()
56514 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
56515 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
56516
56517 /* -----------------------------------------------------------------------------
56518 * global variable support code.
56519 * ----------------------------------------------------------------------------- */
56520
56521 typedef struct swig_globalvar {
56522 char *name; /* Name of global variable */
56523 PyObject *(*get_attr)(void); /* Return the current value */
56524 int (*set_attr)(PyObject *); /* Set the value */
56525 struct swig_globalvar *next;
56526 } swig_globalvar;
56527
56528 typedef struct swig_varlinkobject {
56529 PyObject_HEAD
56530 swig_globalvar *vars;
56531 } swig_varlinkobject;
56532
56533 SWIGINTERN PyObject *
56534 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
56535 return PyString_FromString("<Swig global variables>");
56536 }
56537
56538 SWIGINTERN PyObject *
56539 swig_varlink_str(swig_varlinkobject *v) {
56540 PyObject *str = PyString_FromString("(");
56541 swig_globalvar *var;
56542 for (var = v->vars; var; var=var->next) {
56543 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
56544 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
56545 }
56546 PyString_ConcatAndDel(&str,PyString_FromString(")"));
56547 return str;
56548 }
56549
56550 SWIGINTERN int
56551 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
56552 PyObject *str = swig_varlink_str(v);
56553 fprintf(fp,"Swig global variables ");
56554 fprintf(fp,"%s\n", PyString_AsString(str));
56555 Py_DECREF(str);
56556 return 0;
56557 }
56558
56559 SWIGINTERN void
56560 swig_varlink_dealloc(swig_varlinkobject *v) {
56561 swig_globalvar *var = v->vars;
56562 while (var) {
56563 swig_globalvar *n = var->next;
56564 free(var->name);
56565 free(var);
56566 var = n;
56567 }
56568 }
56569
56570 SWIGINTERN PyObject *
56571 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
56572 PyObject *res = NULL;
56573 swig_globalvar *var = v->vars;
56574 while (var) {
56575 if (strcmp(var->name,n) == 0) {
56576 res = (*var->get_attr)();
56577 break;
56578 }
56579 var = var->next;
56580 }
56581 if (res == NULL && !PyErr_Occurred()) {
56582 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56583 }
56584 return res;
56585 }
56586
56587 SWIGINTERN int
56588 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
56589 int res = 1;
56590 swig_globalvar *var = v->vars;
56591 while (var) {
56592 if (strcmp(var->name,n) == 0) {
56593 res = (*var->set_attr)(p);
56594 break;
56595 }
56596 var = var->next;
56597 }
56598 if (res == 1 && !PyErr_Occurred()) {
56599 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
56600 }
56601 return res;
56602 }
56603
56604 SWIGINTERN PyTypeObject*
56605 swig_varlink_type(void) {
56606 static char varlink__doc__[] = "Swig var link object";
56607 static PyTypeObject varlink_type;
56608 static int type_init = 0;
56609 if (!type_init) {
56610 const PyTypeObject tmp
56611 = {
56612 PyObject_HEAD_INIT(NULL)
56613 0, /* Number of items in variable part (ob_size) */
56614 (char *)"swigvarlink", /* Type name (tp_name) */
56615 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
56616 0, /* Itemsize (tp_itemsize) */
56617 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
56618 (printfunc) swig_varlink_print, /* Print (tp_print) */
56619 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
56620 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
56621 0, /* tp_compare */
56622 (reprfunc) swig_varlink_repr, /* tp_repr */
56623 0, /* tp_as_number */
56624 0, /* tp_as_sequence */
56625 0, /* tp_as_mapping */
56626 0, /* tp_hash */
56627 0, /* tp_call */
56628 (reprfunc)swig_varlink_str, /* tp_str */
56629 0, /* tp_getattro */
56630 0, /* tp_setattro */
56631 0, /* tp_as_buffer */
56632 0, /* tp_flags */
56633 varlink__doc__, /* tp_doc */
56634 0, /* tp_traverse */
56635 0, /* tp_clear */
56636 0, /* tp_richcompare */
56637 0, /* tp_weaklistoffset */
56638 #if PY_VERSION_HEX >= 0x02020000
56639 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
56640 #endif
56641 #if PY_VERSION_HEX >= 0x02030000
56642 0, /* tp_del */
56643 #endif
56644 #ifdef COUNT_ALLOCS
56645 0,0,0,0 /* tp_alloc -> tp_next */
56646 #endif
56647 };
56648 varlink_type = tmp;
56649 varlink_type.ob_type = &PyType_Type;
56650 type_init = 1;
56651 }
56652 return &varlink_type;
56653 }
56654
56655 /* Create a variable linking object for use later */
56656 SWIGINTERN PyObject *
56657 SWIG_Python_newvarlink(void) {
56658 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
56659 if (result) {
56660 result->vars = 0;
56661 }
56662 return ((PyObject*) result);
56663 }
56664
56665 SWIGINTERN void
56666 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
56667 swig_varlinkobject *v = (swig_varlinkobject *) p;
56668 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
56669 if (gv) {
56670 size_t size = strlen(name)+1;
56671 gv->name = (char *)malloc(size);
56672 if (gv->name) {
56673 strncpy(gv->name,name,size);
56674 gv->get_attr = get_attr;
56675 gv->set_attr = set_attr;
56676 gv->next = v->vars;
56677 }
56678 }
56679 v->vars = gv;
56680 }
56681
56682 SWIGINTERN PyObject *
56683 SWIG_globals() {
56684 static PyObject *_SWIG_globals = 0;
56685 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
56686 return _SWIG_globals;
56687 }
56688
56689 /* -----------------------------------------------------------------------------
56690 * constants/methods manipulation
56691 * ----------------------------------------------------------------------------- */
56692
56693 /* Install Constants */
56694 SWIGINTERN void
56695 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
56696 PyObject *obj = 0;
56697 size_t i;
56698 for (i = 0; constants[i].type; ++i) {
56699 switch(constants[i].type) {
56700 case SWIG_PY_POINTER:
56701 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
56702 break;
56703 case SWIG_PY_BINARY:
56704 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
56705 break;
56706 default:
56707 obj = 0;
56708 break;
56709 }
56710 if (obj) {
56711 PyDict_SetItemString(d, constants[i].name, obj);
56712 Py_DECREF(obj);
56713 }
56714 }
56715 }
56716
56717 /* -----------------------------------------------------------------------------*/
56718 /* Fix SwigMethods to carry the callback ptrs when needed */
56719 /* -----------------------------------------------------------------------------*/
56720
56721 SWIGINTERN void
56722 SWIG_Python_FixMethods(PyMethodDef *methods,
56723 swig_const_info *const_table,
56724 swig_type_info **types,
56725 swig_type_info **types_initial) {
56726 size_t i;
56727 for (i = 0; methods[i].ml_name; ++i) {
56728 const char *c = methods[i].ml_doc;
56729 if (c && (c = strstr(c, "swig_ptr: "))) {
56730 int j;
56731 swig_const_info *ci = 0;
56732 const char *name = c + 10;
56733 for (j = 0; const_table[j].type; ++j) {
56734 if (strncmp(const_table[j].name, name,
56735 strlen(const_table[j].name)) == 0) {
56736 ci = &(const_table[j]);
56737 break;
56738 }
56739 }
56740 if (ci) {
56741 size_t shift = (ci->ptype) - types;
56742 swig_type_info *ty = types_initial[shift];
56743 size_t ldoc = (c - methods[i].ml_doc);
56744 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
56745 char *ndoc = (char*)malloc(ldoc + lptr + 10);
56746 if (ndoc) {
56747 char *buff = ndoc;
56748 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
56749 if (ptr) {
56750 strncpy(buff, methods[i].ml_doc, ldoc);
56751 buff += ldoc;
56752 strncpy(buff, "swig_ptr: ", 10);
56753 buff += 10;
56754 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
56755 methods[i].ml_doc = ndoc;
56756 }
56757 }
56758 }
56759 }
56760 }
56761 }
56762
56763 #ifdef __cplusplus
56764 }
56765 #endif
56766
56767 /* -----------------------------------------------------------------------------*
56768 * Partial Init method
56769 * -----------------------------------------------------------------------------*/
56770
56771 #ifdef __cplusplus
56772 extern "C"
56773 #endif
56774 SWIGEXPORT void SWIG_init(void) {
56775 PyObject *m, *d;
56776
56777 /* Fix SwigMethods to carry the callback ptrs when needed */
56778 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
56779
56780 m = Py_InitModule((char *) SWIG_name, SwigMethods);
56781 d = PyModule_GetDict(m);
56782
56783 SWIG_InitializeModule(0);
56784 SWIG_InstallConstants(d,swig_const_table);
56785
56786
56787
56788 #ifndef wxPyUSE_EXPORT
56789 // Make our API structure a CObject so other modules can import it
56790 // from this module.
56791 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
56792 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
56793 Py_XDECREF(cobj);
56794 #endif
56795
56796 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
56797 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
56798 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
56799 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
56800 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
56801 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
56802 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
56803 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
56804 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
56805 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
56806 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
56807 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
56808 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
56809 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
56810 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
56811 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
56812 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
56813 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
56814 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
56815 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
56816 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
56817 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
56818 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
56819 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
56820 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
56821 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
56822 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
56823 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
56824 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
56825 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
56826 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
56827 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
56828 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
56829 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
56830 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
56831 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
56832 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
56833 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
56834 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
56835 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
56836 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
56837 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
56838 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
56839 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
56840 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
56841 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
56842 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
56843 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
56844 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
56845 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
56846 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
56847 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
56848 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
56849 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
56850 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
56851 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
56852 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
56853 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
56854 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
56855 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
56856 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
56857 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
56858 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
56859 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
56860 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
56861 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
56862 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
56863 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
56864 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
56865 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
56866 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
56867 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
56868 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
56869 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
56870 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
56871 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
56872 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
56873 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
56874 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
56875 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
56876 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
56877 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
56878 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
56879 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
56880 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
56881 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
56882 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
56883 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
56884 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
56885 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
56886 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
56887 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
56888 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
56889 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
56890 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
56891 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
56892 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
56893 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
56894 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
56895 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
56896 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
56897 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
56898 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
56899 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
56900 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
56901 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
56902 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
56903 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
56904 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
56905 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
56906 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
56907 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
56908 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
56909 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
56910 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
56911 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
56912 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
56913 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
56914 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
56915 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
56916 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
56917 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
56918 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
56919 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
56920 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
56921 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
56922 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
56923 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
56924 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
56925 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
56926 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
56927 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
56928 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
56929 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
56930 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
56931 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
56932 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
56933 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
56934 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
56935 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
56936 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
56937 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
56938 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
56939 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
56940 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
56941 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
56942 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
56943 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
56944 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
56945 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
56946 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
56947 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
56948 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
56949 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
56950 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
56951 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
56952 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
56953 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
56954 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
56955 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
56956 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
56957 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
56958 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
56959 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
56960 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
56961 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56962 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56963 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56964 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56965 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56966 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56967 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56968 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56969 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56970 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56971 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56972 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56973 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56974 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56975 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56976 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56977 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56978 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56979 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56980 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56981 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56982 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56983 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56984 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56985 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56986 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56987 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56988 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56989 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56990 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56991 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56992 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56993 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56994 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56995 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56996 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56997 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56998 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56999 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
57000 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
57001 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
57002 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
57003 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
57004 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
57005 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
57006 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
57007 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
57008 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
57009 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
57010 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
57011 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
57012 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
57013 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
57014 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
57015 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
57016 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
57017 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
57018 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
57019 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
57020 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
57021 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
57022 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
57023 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
57024 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
57025 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
57026 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
57027 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
57028 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
57029 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
57030 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
57031 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
57032 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
57033 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
57034 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
57035 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
57036 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
57037 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
57038 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
57039 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
57040 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
57041 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
57042 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
57043 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
57044 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
57045 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
57046 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
57047 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
57048 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
57049 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
57050 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
57051 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
57052 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
57053 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
57054 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
57055 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
57056 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
57057 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
57058 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
57059 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
57060 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
57061 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
57062 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
57063 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
57064 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
57065 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
57066 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
57067 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
57068 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
57069 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
57070 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
57071 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
57072 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
57073 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
57074 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
57075 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
57076 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
57077 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
57078 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
57079 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
57080 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
57081 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
57082 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
57083 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
57084 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
57085 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
57086 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
57087 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
57088 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
57089 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
57090 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
57091 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
57092 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
57093 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
57094 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
57095 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
57096 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
57097 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
57098 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
57099 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
57100 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
57101 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
57102 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
57103 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
57104 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
57105 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
57106 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
57107 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
57108 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
57109 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
57110 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
57111 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
57112 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
57113 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
57114 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
57115 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
57116 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
57117 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
57118 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
57119 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
57120 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
57121 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
57122 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
57123 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
57124 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
57125 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
57126 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
57127 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
57128 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
57129 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
57130 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
57131 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
57132 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
57133 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
57134 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
57135 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
57136 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
57137 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
57138 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
57139 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
57140 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
57141 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
57142 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
57143 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
57144 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
57145 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
57146 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
57147 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
57148 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
57149 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
57150 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
57151 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
57152 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
57153 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
57154 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
57155 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
57156 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
57157 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
57158 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
57159 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
57160 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
57161 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
57162 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
57163 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
57164 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
57165 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
57166 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
57167 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
57168 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
57169 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
57170 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
57171 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
57172 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
57173 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
57174 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
57175 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
57176 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
57177 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
57178 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
57179 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
57180 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
57181 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
57182 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
57183 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
57184 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
57185 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
57186 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
57187 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
57188 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
57189 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
57190 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
57191 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
57192 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
57193 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
57194 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
57195 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
57196 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
57197 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
57198 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
57199 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
57200 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
57201 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
57202 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
57203 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
57204 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
57205 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
57206 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
57207 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
57208 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
57209 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
57210 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
57211 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
57212 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
57213 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
57214 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
57215 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
57216 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
57217 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
57218 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
57219 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
57220 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
57221 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
57222 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
57223 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
57224 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
57225 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
57226 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
57227 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
57228 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
57229 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
57230 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
57231 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
57232 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
57233 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
57234 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
57235 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
57236 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
57237 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
57238 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
57239 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
57240 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
57241 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
57242 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
57243 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
57244 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
57245 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
57246 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
57247 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
57248 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
57249 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
57250 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
57251 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
57252 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
57253 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
57254 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
57255 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
57256 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
57257 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
57258 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
57259 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
57260 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
57261 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
57262 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
57263 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
57264 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
57265 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
57266 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
57267 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
57268 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
57269 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
57270 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
57271 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
57272 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
57273 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
57274 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
57275 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
57276 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
57277 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
57278 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
57279 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
57280 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
57281 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
57282 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
57283 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
57284 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
57285 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
57286 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
57287 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
57288 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
57289 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
57290 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
57291 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
57292 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
57293 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
57294 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
57295 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
57296 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
57297 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
57298 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
57299 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
57300 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
57301 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
57302 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
57303 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
57304 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
57305 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
57306 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
57307 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
57308 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
57309 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
57310 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
57311 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
57312 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
57313 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
57314 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
57315 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
57316 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
57317 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
57318 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
57319 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
57320 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
57321 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
57322 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
57323 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
57324 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
57325 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
57326 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
57327 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
57328 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
57329 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
57330 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
57331 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
57332 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
57333 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
57334 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
57335 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
57336 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
57337 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
57338 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
57339 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
57340 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
57341 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
57342 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
57343 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
57344 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
57345 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
57346 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
57347 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
57348 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
57349 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
57350 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
57351 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
57352 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
57353 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
57354 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
57355 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
57356 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
57357 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
57358 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
57359 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
57360 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
57361 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
57362 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
57363 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
57364 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
57365 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
57366 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
57367 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
57368 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
57369 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
57370 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
57371 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
57372 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
57373 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
57374 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
57375 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
57376 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
57377 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
57378 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
57379 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
57380 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
57381 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
57382 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
57383 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
57384 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
57385 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
57386 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
57387 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
57388 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
57389 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
57390 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
57391 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
57392 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
57393 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
57394 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
57395 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
57396 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
57397 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
57398 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
57399 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
57400 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
57401 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
57402 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
57403 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
57404 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
57405 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
57406 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
57407 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
57408 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
57409 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
57410 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
57411 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
57412 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
57413 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
57414 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
57415 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
57416 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
57417 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
57418 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
57419 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
57420 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
57421 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
57422 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
57423 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
57424 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
57425 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
57426 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
57427 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
57428 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
57429 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
57430 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
57431 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
57432 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
57433 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
57434 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
57435 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
57436 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
57437 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
57438 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
57439 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
57440 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
57441 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
57442 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
57443 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
57444 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
57445 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
57446 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
57447 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
57448 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
57449 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
57450 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
57451 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
57452
57453 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
57454
57455
57456 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
57457
57458 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
57459 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
57460 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
57461 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
57462 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
57463 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
57464 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
57465 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
57466 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
57467 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
57468 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
57469 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
57470 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
57471 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
57472 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
57473 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
57474 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
57475 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
57476 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
57477 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
57478 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
57479 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
57480 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
57481 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
57482 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
57483 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
57484 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
57485 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
57486 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
57487 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
57488 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
57489 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
57490 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
57491 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
57492 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
57493 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
57494 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
57495 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
57496 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
57497 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
57498 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
57499 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
57500 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
57501 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
57502 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
57503 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
57504 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
57505 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
57506 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
57507 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
57508 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
57509 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
57510 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
57511 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
57512 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
57513 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
57514 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
57515 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
57516 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
57517 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
57518 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
57519 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
57520 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
57521 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
57522 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
57523 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
57524 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
57525 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
57526 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
57527 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
57528 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
57529 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
57530 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
57531 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
57532 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
57533 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
57534 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
57535 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
57536 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
57537 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
57538 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
57539 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
57540 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
57541 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
57542 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
57543 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
57544 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
57545 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
57546 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
57547 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
57548 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
57549 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
57550 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
57551 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
57552 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
57553 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
57554 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
57555 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
57556 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
57557 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
57558 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
57559 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
57560 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
57561 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
57562 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
57563 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
57564 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
57565 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
57566 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
57567 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
57568 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
57569 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
57570 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
57571 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
57572 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
57573 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
57574 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
57575 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
57576 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
57577 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
57578 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
57579 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
57580 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
57581 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
57582 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
57583 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
57584 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
57585 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
57586 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
57587 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
57588 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
57589 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
57590 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
57591 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
57592 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
57593 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
57594 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
57595 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
57596 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
57597 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
57598 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
57599 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
57600 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
57601 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
57602 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
57603 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
57604 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
57605 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
57606 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
57607 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
57608 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
57609 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
57610 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
57611 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
57612 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
57613 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
57614 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
57615 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
57616 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
57617 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
57618 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
57619 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
57620 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
57621 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
57622 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
57623 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
57624 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
57625 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
57626 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
57627 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
57628 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
57629 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
57630 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
57631 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
57632 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
57633 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
57634 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
57635 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
57636 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
57637 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
57638 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
57639 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
57640 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
57641 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
57642 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
57643 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
57644 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
57645 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
57646 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
57647 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
57648 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
57649 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
57650 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
57651 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
57652 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
57653 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
57654 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
57655 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
57656 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
57657 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
57658 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
57659 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
57660 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
57661 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
57662 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
57663 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
57664 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
57665 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
57666 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
57667 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
57668 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
57669 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
57670
57671 // Initialize threading, some globals and such
57672 __wxPyPreStart(d);
57673
57674
57675 // Although these are defined in __version__ they need to be here too so
57676 // that an assert can be done to ensure that the wxPython and the wxWindows
57677 // versions match.
57678 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
57679 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
57680 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
57681
57682 }
57683
wxWidgets (Impactor)